RTEMS-5
Annotated Report
Fri Aug 10 12:56:55 2018
40004b24 <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
40004b24: 9d e3 bf a0 save %sp, -96, %sp
Heap_Control *heap = RTEMS_Malloc_Heap;
if ( !rtems_configuration_get_unified_work_area() ) {
40004b28: 03 10 00 41 sethi %hi(0x40010400), %g1
40004b2c: c2 08 63 f5 ldub [ %g1 + 0x3f5 ], %g1 ! 400107f5 <Configuration+0x31>
40004b30: 80 a0 60 00 cmp %g1, 0
40004b34: 12 80 00 19 bne 40004b98 <RTEMS_Malloc_Initialize+0x74>
<== NEVER TAKEN
40004b38: 80 a6 60 00 cmp %i1, 0
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
uintptr_t page_size = CPU_HEAP_ALIGNMENT;
size_t i;
for (i = 0; i < area_count; ++i) {
40004b3c: 02 80 00 19 be 40004ba0 <RTEMS_Malloc_Initialize+0x7c>
<== NEVER TAKEN
40004b40: 03 10 00 49 sethi %hi(0x40012400), %g1
Heap_Control *heap = RTEMS_Malloc_Heap;
40004b44: f8 00 62 8c ld [ %g1 + 0x28c ], %i4 ! 4001268c <RTEMS_Malloc_Heap>
40004b48: b3 2e 60 03 sll %i1, 3, %i1
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
40004b4c: 37 10 00 1f sethi %hi(0x40007c00), %i3
40004b50: b2 06 00 19 add %i0, %i1, %i1
40004b54: b6 16 e2 0c or %i3, 0x20c, %i3
40004b58: ba 10 00 1b mov %i3, %i5
const Heap_Area *area = &areas [i];
uintptr_t space_available = (*init_or_extend)(
40004b5c: d4 06 20 04 ld [ %i0 + 4 ], %o2
40004b60: d2 06 00 00 ld [ %i0 ], %o1
40004b64: 96 10 20 08 mov 8, %o3
40004b68: 9f c7 40 00 call %i5
40004b6c: 90 10 00 1c mov %i4, %o0
area->begin,
area->size,
page_size
);
if ( space_available > 0 ) {
40004b70: 80 a2 20 00 cmp %o0, 0
40004b74: 32 80 00 02 bne,a 40004b7c <RTEMS_Malloc_Initialize+0x58>
<== ALWAYS TAKEN
40004b78: ba 10 00 1a mov %i2, %i5
40004b7c: b0 06 20 08 add %i0, 8, %i0
for (i = 0; i < area_count; ++i) {
40004b80: 80 a6 00 19 cmp %i0, %i1
40004b84: 32 bf ff f7 bne,a 40004b60 <RTEMS_Malloc_Initialize+0x3c>
<== NEVER TAKEN
40004b88: d4 06 20 04 ld [ %i0 + 4 ], %o2
<== NOT EXECUTED
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
40004b8c: 80 a7 40 1b cmp %i5, %i3
40004b90: 02 80 00 04 be 40004ba0 <RTEMS_Malloc_Initialize+0x7c>
<== NEVER TAKEN
40004b94: 01 00 00 00 nop
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
}
}
}
40004b98: 81 c7 e0 08 ret
40004b9c: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
40004ba0: 40 00 0d 64 call 40008130 <_Internal_error>
<== NOT EXECUTED
40004ba4: 90 10 20 17 mov 0x17, %o0
<== NOT EXECUTED
40004ba8: 01 00 00 00 nop
<== NOT EXECUTED
40004730 <_Console_simple_Read>:
ssize_t _Console_simple_Read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
40004730: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
ssize_t n;
buf = buffer;
n = (ssize_t) count;
for ( i = 0; i < n; ++i ) {
40004734: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40004738: 04 80 00 0c ble 40004768 <_Console_simple_Read+0x38>
<== NOT EXECUTED
4000473c: ba 10 20 00 clr %i5
<== NOT EXECUTED
int c;
do {
c = getchark();
40004740: 40 00 00 22 call 400047c8 <getchark>
<== NOT EXECUTED
40004744: 01 00 00 00 nop
<== NOT EXECUTED
} while (c == -1);
40004748: 80 a2 3f ff cmp %o0, -1
<== NOT EXECUTED
4000474c: 02 bf ff fd be 40004740 <_Console_simple_Read+0x10>
<== NOT EXECUTED
40004750: 01 00 00 00 nop
<== NOT EXECUTED
buf[ i ] = (char) c;
40004754: d0 2e 40 1d stb %o0, [ %i1 + %i5 ]
<== NOT EXECUTED
for ( i = 0; i < n; ++i ) {
40004758: ba 07 60 01 inc %i5
<== NOT EXECUTED
4000475c: 80 a6 80 1d cmp %i2, %i5
<== NOT EXECUTED
40004760: 12 bf ff f8 bne 40004740 <_Console_simple_Read+0x10>
<== NOT EXECUTED
40004764: 01 00 00 00 nop
<== NOT EXECUTED
}
return n;
}
40004768: 81 c7 e0 08 ret
<== NOT EXECUTED
4000476c: 91 e8 00 1a restore %g0, %i2, %o0
<== NOT EXECUTED
40004af0 <_Malloc_Deferred_free>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40004af0: 91 d0 20 09 ta 9
<== NOT EXECUTED
old_last = tail->previous;
40004af4: 05 10 00 49 sethi %hi(0x40012400), %g2
<== NOT EXECUTED
40004af8: 84 10 a2 b8 or %g2, 0x2b8, %g2 ! 400126b8 <_Malloc_GC_list>
<== NOT EXECUTED
40004afc: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
the_node->next = tail;
40004b00: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
40004b04: c8 22 00 00 st %g4, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
40004b08: d0 20 a0 08 st %o0, [ %g2 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
40004b0c: d0 20 c0 00 st %o0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40004b10: c6 22 20 04 st %g3, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40004b14: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40004b18: 01 00 00 00 nop
<== NOT EXECUTED
rtems_interrupt_lock_acquire( &_Malloc_GC_lock, &lock_context );
rtems_chain_initialize_node( node );
rtems_chain_append_unprotected( &_Malloc_GC_list, node );
rtems_interrupt_lock_release( &_Malloc_GC_lock, &lock_context );
}
40004b1c: 81 c3 e0 08 retl
<== NOT EXECUTED
40004b20: 01 00 00 00 nop
<== NOT EXECUTED
400049a4 <_Malloc_Process_deferred_frees>:
return p;
}
void _Malloc_Process_deferred_frees( void )
{
400049a4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400049a8: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
400049ac: 3b 10 00 49 sethi %hi(0x40012400), %i5
400049b0: d0 07 62 b8 ld [ %i5 + 0x2b8 ], %o0 ! 400126b8 <_Malloc_GC_list>
400049b4: ba 17 62 b8 or %i5, 0x2b8, %i5
if ( !_Chain_Is_empty(the_chain))
400049b8: b8 07 60 04 add %i5, 4, %i4
400049bc: 80 a2 00 1c cmp %o0, %i4
400049c0: 02 80 00 0e be 400049f8 <_Malloc_Process_deferred_frees+0x54>
<== ALWAYS TAKEN
400049c4: 01 00 00 00 nop
new_first = old_first->next;
400049c8: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
head->next = new_first;
400049cc: c4 27 40 00 st %g2, [ %i5 ]
<== NOT EXECUTED
new_first->previous = head;
400049d0: fa 20 a0 04 st %i5, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400049d4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400049d8: 01 00 00 00 nop
<== NOT EXECUTED
/*
* If some free's have been deferred, then do them now.
*/
while ( ( to_be_freed = _Malloc_Get_deferred_free() ) != NULL ) {
free( to_be_freed );
400049dc: 7f ff ff 65 call 40004770 <free>
<== NOT EXECUTED
400049e0: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400049e4: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
400049e8: d0 07 40 00 ld [ %i5 ], %o0
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
400049ec: 80 a2 00 1c cmp %o0, %i4
<== NOT EXECUTED
400049f0: 32 bf ff f7 bne,a 400049cc <_Malloc_Process_deferred_frees+0x28>
<== NOT EXECUTED
400049f4: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400049f8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400049fc: 01 00 00 00 nop
}
}
40004a00: 81 c7 e0 08 ret
40004a04: 81 e8 00 00 restore
40004968 <_Malloc_System_state>:
_System_state_Current = state;
}
RTEMS_INLINE_ROUTINE System_state_Codes _System_state_Get ( void )
{
return _System_state_Current;
40004968: 03 10 00 4f sethi %hi(0x40013c00), %g1
<== NOT EXECUTED
4000496c: c2 00 62 3c ld [ %g1 + 0x23c ], %g1 ! 40013e3c <_System_state_Current>
<== NOT EXECUTED
if ( _Thread_Dispatch_is_enabled() ) {
return MALLOC_SYSTEM_STATE_NORMAL;
} else {
return MALLOC_SYSTEM_STATE_NO_ALLOCATION;
}
} else if ( _System_state_Is_before_multitasking( state ) ) {
40004970: 84 18 60 01 xor %g1, 1, %g2
<== NOT EXECUTED
return MALLOC_SYSTEM_STATE_NORMAL;
} else {
return MALLOC_SYSTEM_STATE_NO_PROTECTION;
40004974: 80 a0 00 02 cmp %g0, %g2
<== NOT EXECUTED
40004978: 90 40 20 00 addx %g0, 0, %o0
<== NOT EXECUTED
if ( _System_state_Is_up( state ) ) {
4000497c: 80 a0 60 02 cmp %g1, 2
<== NOT EXECUTED
40004980: 02 80 00 04 be 40004990 <_Malloc_System_state+0x28>
<== NOT EXECUTED
40004984: 01 00 00 00 nop
<== NOT EXECUTED
}
}
40004988: 81 c3 e0 08 retl
<== NOT EXECUTED
4000498c: 01 00 00 00 nop
<== NOT EXECUTED
40004990: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
return MALLOC_SYSTEM_STATE_NO_ALLOCATION;
40004994: 80 a0 00 01 cmp %g0, %g1
<== NOT EXECUTED
40004998: 90 40 20 00 addx %g0, 0, %o0
<== NOT EXECUTED
}
4000499c: 81 c3 e0 08 retl
<== NOT EXECUTED
400049a0: 91 2a 20 01 sll %o0, 1, %o0
<== NOT EXECUTED
40010444 <_free_r>:
struct _reent *ignored,
void *ptr
)
{
(void) ignored;
free( ptr );
40010444: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
40010448: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4001044c: 7f ff d0 c9 call 40004770 <free>
<== NOT EXECUTED
40010450: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40004860 <_gettimeofday_r>:
int _gettimeofday_r(
struct _reent *ignored_reentrancy_stuff RTEMS_UNUSED,
struct timeval *tp,
void *__tz
)
{
40004860: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( !tp )
40004864: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40004868: 02 80 00 06 be 40004880 <_gettimeofday_r+0x20>
<== NOT EXECUTED
4000486c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40004870: 40 00 11 c7 call 40008f8c <_Timecounter_Microtime>
<== NOT EXECUTED
40004874: b0 10 20 00 clr %i0
<== NOT EXECUTED
struct timezone *tzp = __tz;
return gettimeofday( tp, tzp );
}
40004878: 81 c7 e0 08 ret
<== NOT EXECUTED
4000487c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
40004880: 40 00 2a 5f call 4000f1fc <__errno>
<== NOT EXECUTED
40004884: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004888: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
4000488c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004890: 81 c7 e0 08 ret
<== NOT EXECUTED
40004894: 81 e8 00 00 restore
<== NOT EXECUTED
4000f108 <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
4000f108: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_libio_t *iop;
unsigned int flags;
int rc;
if ( (uint32_t) fd >= rtems_libio_number_iops ) {
4000f10c: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
4000f110: c2 00 61 60 ld [ %g1 + 0x160 ], %g1 ! 40010960 <rtems_libio_number_iops>
<== NOT EXECUTED
4000f114: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
4000f118: 1a 80 00 1b bcc 4000f184 <close+0x7c>
<== NOT EXECUTED
4000f11c: 01 00 00 00 nop
<== NOT EXECUTED
4000f120: b7 2e 20 01 sll %i0, 1, %i3
<== NOT EXECUTED
4000f124: b0 06 c0 18 add %i3, %i0, %i0
<== NOT EXECUTED
4000f128: 37 10 00 4e sethi %hi(0x40013800), %i3
<== NOT EXECUTED
4000f12c: b9 2e 20 04 sll %i0, 4, %i4
<== NOT EXECUTED
4000f130: b6 16 e1 a8 or %i3, 0x1a8, %i3
<== NOT EXECUTED
4000f134: b8 06 c0 1c add %i3, %i4, %i4
<== NOT EXECUTED
4000f138: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
unsigned int actual;
(void) succ;
(void) fail;
_ISR_Local_disable( level );
actual = *obj;
4000f13c: 10 80 00 0f b 4000f178 <close+0x70>
<== NOT EXECUTED
4000f140: ba 10 00 1c mov %i4, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000f144: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000f148: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
success = ( actual == *expected );
if ( success ) {
4000f14c: 80 a1 00 03 cmp %g4, %g3
<== NOT EXECUTED
4000f150: 12 80 00 03 bne 4000f15c <close+0x54>
<== NOT EXECUTED
4000f154: 84 08 ae ff and %g2, 0xeff, %g2
<== NOT EXECUTED
*obj = desired;
4000f158: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000f15c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000f160: 01 00 00 00 nop
<== NOT EXECUTED
desired,
ATOMIC_ORDER_ACQ_REL,
ATOMIC_ORDER_RELAXED
);
if ( success ) {
4000f164: 80 a1 00 03 cmp %g4, %g3
<== NOT EXECUTED
4000f168: 02 80 00 0d be 4000f19c <close+0x94>
<== NOT EXECUTED
4000f16c: 80 88 f0 00 btst -4096, %g3
<== NOT EXECUTED
break;
}
if ( ( flags & ~( LIBIO_FLAGS_REFERENCE_INC - 1U ) ) != 0 ) {
4000f170: 12 80 00 16 bne 4000f1c8 <close+0xc0>
<== NOT EXECUTED
4000f174: 84 10 00 03 mov %g3, %g2
<== NOT EXECUTED
if ( ( flags & LIBIO_FLAGS_OPEN ) == 0 ) {
4000f178: 80 88 a1 00 btst 0x100, %g2
<== NOT EXECUTED
4000f17c: 12 bf ff f2 bne 4000f144 <close+0x3c>
<== NOT EXECUTED
4000f180: 88 08 af ff and %g2, 0xfff, %g4
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
4000f184: 40 00 00 1e call 4000f1fc <__errno>
<== NOT EXECUTED
4000f188: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000f18c: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
4000f190: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000f194: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f198: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
}
}
rc = (*iop->pathinfo.handlers->close_h)( iop );
4000f19c: b1 2e 20 04 sll %i0, 4, %i0
<== NOT EXECUTED
4000f1a0: b6 06 c0 18 add %i3, %i0, %i3
<== NOT EXECUTED
4000f1a4: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
<== NOT EXECUTED
4000f1a8: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
4000f1ac: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000f1b0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000f1b4: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
rtems_libio_free( iop );
4000f1b8: 7f ff fc 85 call 4000e3cc <rtems_libio_free>
<== NOT EXECUTED
4000f1bc: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
return rc;
}
4000f1c0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f1c4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBUSY );
4000f1c8: 40 00 00 0d call 4000f1fc <__errno>
<== NOT EXECUTED
4000f1cc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000f1d0: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
4000f1d4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000f1d8: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f1dc: 81 e8 00 00 restore
<== NOT EXECUTED
40004770 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
40004770: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( !ptr )
40004774: ba 96 20 00 orcc %i0, 0, %i5
<== NOT EXECUTED
40004778: 02 80 00 0d be 400047ac <free+0x3c>
<== NOT EXECUTED
4000477c: 01 00 00 00 nop
<== NOT EXECUTED
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _Malloc_System_state() != MALLOC_SYSTEM_STATE_NORMAL ) {
40004780: 40 00 00 7a call 40004968 <_Malloc_System_state>
<== NOT EXECUTED
40004784: 01 00 00 00 nop
<== NOT EXECUTED
40004788: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000478c: 12 80 00 0a bne 400047b4 <free+0x44>
<== NOT EXECUTED
40004790: 03 10 00 49 sethi %hi(0x40012400), %g1
<== NOT EXECUTED
_Malloc_Deferred_free(ptr);
return;
}
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
40004794: d0 00 62 8c ld [ %g1 + 0x28c ], %o0 ! 4001268c <RTEMS_Malloc_Heap>
<== NOT EXECUTED
40004798: 40 00 14 47 call 400098b4 <_Protected_heap_Free>
<== NOT EXECUTED
4000479c: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
400047a0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400047a4: 02 80 00 06 be 400047bc <free+0x4c>
<== NOT EXECUTED
400047a8: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
rtems_fatal( RTEMS_FATAL_SOURCE_INVALID_HEAP_FREE, (rtems_fatal_code) ptr );
}
}
400047ac: 81 c7 e0 08 ret
<== NOT EXECUTED
400047b0: 81 e8 00 00 restore
<== NOT EXECUTED
_Malloc_Deferred_free(ptr);
400047b4: 40 00 00 cf call 40004af0 <_Malloc_Deferred_free>
<== NOT EXECUTED
400047b8: 81 e8 00 00 restore
<== NOT EXECUTED
400047bc: 40 00 0e 4a call 400080e4 <_Terminate>
<== NOT EXECUTED
400047c0: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
400047c4: 01 00 00 00 nop
<== NOT EXECUTED
4000e220 <ftruncate>:
#include <unistd.h>
#include <rtems/libio_.h>
int ftruncate( int fd, off_t length )
{
4000e220: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int rv = 0;
if ( length >= 0 ) {
4000e224: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
4000e228: 06 80 00 39 bl 4000e30c <ftruncate+0xec>
<== NOT EXECUTED
4000e22c: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
rtems_libio_t *iop;
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EINVAL );
4000e230: c2 00 61 60 ld [ %g1 + 0x160 ], %g1 ! 40010960 <rtems_libio_number_iops>
<== NOT EXECUTED
4000e234: 80 a6 00 01 cmp %i0, %g1
<== NOT EXECUTED
4000e238: 1a 80 00 1f bcc 4000e2b4 <ftruncate+0x94>
<== NOT EXECUTED
4000e23c: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
4000e240: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
4000e244: 31 10 00 4e sethi %hi(0x40013800), %i0
<== NOT EXECUTED
4000e248: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
4000e24c: b0 16 21 a8 or %i0, 0x1a8, %i0
<== NOT EXECUTED
4000e250: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e254: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
4000e258: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
4000e25c: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
4000e260: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e264: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e268: 01 00 00 00 nop
<== NOT EXECUTED
4000e26c: 82 08 a1 04 and %g2, 0x104, %g1
<== NOT EXECUTED
4000e270: 80 a0 61 04 cmp %g1, 0x104
<== NOT EXECUTED
4000e274: 12 80 00 16 bne 4000e2cc <ftruncate+0xac>
<== NOT EXECUTED
4000e278: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
rv = (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
4000e27c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4000e280: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
<== NOT EXECUTED
4000e284: 94 10 00 1a mov %i2, %o2
<== NOT EXECUTED
4000e288: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e28c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
4000e290: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e294: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4000e298: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000e29c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000e2a0: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e2a4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e2a8: 01 00 00 00 nop
<== NOT EXECUTED
4000e2ac: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e2b0: 81 e8 00 00 restore
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EINVAL );
4000e2b4: 40 00 03 d2 call 4000f1fc <__errno>
<== NOT EXECUTED
4000e2b8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000e2bc: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
4000e2c0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000e2c4: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e2c8: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000e2cc: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000e2d0: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
4000e2d4: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
4000e2d8: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000e2dc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000e2e0: 01 00 00 00 nop
<== NOT EXECUTED
4000e2e4: 84 08 a1 00 and %g2, 0x100, %g2
<== NOT EXECUTED
4000e2e8: 80 a0 00 02 cmp %g0, %g2
<== NOT EXECUTED
4000e2ec: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000e2f0: 40 00 03 c3 call 4000f1fc <__errno>
<== NOT EXECUTED
4000e2f4: ba 60 20 00 subx %g0, 0, %i5
<== NOT EXECUTED
4000e2f8: ba 0f 60 0d and %i5, 0xd, %i5
<== NOT EXECUTED
4000e2fc: ba 07 60 09 add %i5, 9, %i5
<== NOT EXECUTED
4000e300: fa 22 00 00 st %i5, [ %o0 ]
<== NOT EXECUTED
4000e304: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e308: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_libio_iop_drop( iop );
} else {
errno = EINVAL;
4000e30c: 40 00 03 bc call 4000f1fc <__errno>
<== NOT EXECUTED
4000e310: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000e314: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4000e318: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
4000e31c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e320: 81 e8 00 00 restore
<== NOT EXECUTED
400047c8 <getchark>:
#include <rtems.h>
#include <rtems/bspIo.h>
int getchark(void)
{
400047c8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( BSP_poll_char )
400047cc: 03 10 00 4a sethi %hi(0x40012800), %g1
<== NOT EXECUTED
400047d0: d0 00 62 60 ld [ %g1 + 0x260 ], %o0 ! 40012a60 <BSP_poll_char>
<== NOT EXECUTED
400047d4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400047d8: 02 80 00 06 be 400047f0 <getchark+0x28>
<== NOT EXECUTED
400047dc: 01 00 00 00 nop
<== NOT EXECUTED
return (*BSP_poll_char)();
400047e0: 9f c2 00 00 call %o0
<== NOT EXECUTED
400047e4: 01 00 00 00 nop
<== NOT EXECUTED
400047e8: 81 c7 e0 08 ret
<== NOT EXECUTED
400047ec: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
return -1;
}
400047f0: 81 c7 e0 08 ret
<== NOT EXECUTED
400047f4: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
40004828 <gettimeofday>:
*/
int gettimeofday(
struct timeval *__restrict tp,
void *__restrict __tz RTEMS_UNUSED
)
{
40004828: 9d e3 bf a0 save %sp, -96, %sp
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
4000482c: 80 a6 20 00 cmp %i0, 0
40004830: 02 80 00 06 be 40004848 <gettimeofday+0x20>
<== NEVER TAKEN
40004834: 90 10 00 18 mov %i0, %o0
RTEMS_INLINE_ROUTINE void _TOD_Get_timeval(
struct timeval *time
)
{
_Timecounter_Microtime( time );
40004838: 40 00 11 d5 call 40008f8c <_Timecounter_Microtime>
4000483c: b0 10 20 00 clr %i0
* with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X
* do it. This puts us in good company.
*/
return 0;
}
40004840: 81 c7 e0 08 ret
40004844: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EFAULT );
40004848: 40 00 2a 6d call 4000f1fc <__errno>
<== NOT EXECUTED
4000484c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004850: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
40004854: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004858: 81 c7 e0 08 ret
<== NOT EXECUTED
4000485c: 81 e8 00 00 restore
<== NOT EXECUTED
40004bac <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
40004bac: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
/*
* Validate the parameters
*/
if ( !size )
40004bb0: 80 a6 20 00 cmp %i0, 0
40004bb4: 02 80 00 0a be 40004bdc <malloc+0x30>
<== NEVER TAKEN
40004bb8: 90 10 00 18 mov %i0, %o0
return (void *) 0;
return_this = rtems_heap_allocate_aligned_with_boundary( size, 0, 0 );
40004bbc: 94 10 20 00 clr %o2
40004bc0: 7f ff ff 92 call 40004a08 <rtems_heap_allocate_aligned_with_boundary>
40004bc4: 92 10 20 00 clr %o1
if ( !return_this ) {
40004bc8: b0 92 20 00 orcc %o0, 0, %i0
40004bcc: 02 80 00 06 be 40004be4 <malloc+0x38>
<== NEVER TAKEN
40004bd0: 01 00 00 00 nop
errno = ENOMEM;
return (void *) 0;
}
return return_this;
}
40004bd4: 81 c7 e0 08 ret
40004bd8: 81 e8 00 00 restore
40004bdc: 81 c7 e0 08 ret
<== NOT EXECUTED
40004be0: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
errno = ENOMEM;
40004be4: 40 00 29 86 call 4000f1fc <__errno>
<== NOT EXECUTED
40004be8: 01 00 00 00 nop
<== NOT EXECUTED
40004bec: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb>
<== NOT EXECUTED
40004bf0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return (void *) 0;
40004bf4: 81 c7 e0 08 ret
<== NOT EXECUTED
40004bf8: 81 e8 00 00 restore
<== NOT EXECUTED
40004cc4 <mknod>:
* This routine is not defined in the POSIX 1003.1b standard but is
* commonly supported on most UNIX and POSIX systems. It is the
* foundation for creating file system objects.
*/
int mknod( const char *path, mode_t mode, dev_t dev )
{
40004cc4: 9d e3 bf 68 save %sp, -152, %sp
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK
| RTEMS_FS_MAKE
| RTEMS_FS_EXCLUSIVE
| (S_ISDIR(mode) ? RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS : 0);
40004cc8: 03 00 00 3c sethi %hi(0xf000), %g1
40004ccc: 05 00 00 10 sethi %hi(0x4000), %g2
40004cd0: 82 0e 40 01 and %i1, %g1, %g1
40004cd4: 80 a0 40 02 cmp %g1, %g2
40004cd8: 02 80 00 03 be 40004ce4 <mknod+0x20>
<== ALWAYS TAKEN
40004cdc: 94 10 20 f8 mov 0xf8, %o2
40004ce0: 94 10 20 78 mov 0x78, %o2
<== NOT EXECUTED
const rtems_filesystem_location_info_t *currentloc =
40004ce4: 92 10 00 18 mov %i0, %o1
40004ce8: 40 00 03 5e call 40005a60 <rtems_filesystem_eval_path_start>
40004cec: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
rv = rtems_filesystem_mknod(
40004cf0: d4 07 bf d4 ld [ %fp + -44 ], %o2
40004cf4: d2 07 bf d0 ld [ %fp + -48 ], %o1
40004cf8: 98 10 00 1a mov %i2, %o4
40004cfc: 9a 10 00 1b mov %i3, %o5
40004d00: 7f ff ff c6 call 40004c18 <rtems_filesystem_mknod>
40004d04: 96 10 00 19 mov %i1, %o3
40004d08: b0 10 00 08 mov %o0, %i0
rtems_filesystem_eval_path_get_tokenlen( &ctx ),
mode,
dev
);
rtems_filesystem_eval_path_cleanup( &ctx );
40004d0c: 40 00 03 61 call 40005a90 <rtems_filesystem_eval_path_cleanup>
40004d10: 90 07 bf c8 add %fp, -56, %o0
return rv;
}
40004d14: 81 c7 e0 08 ret
40004d18: 81 e8 00 00 restore
40004d1c <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
40004d1c: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
if (
40004d20: 80 a6 e0 01 cmp %i3, 1
40004d24: 18 80 00 b2 bgu 40004fec <mount+0x2d0>
<== NEVER TAKEN
40004d28: 01 00 00 00 nop
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
40004d2c: 40 00 25 f1 call 4000e4f0 <rtems_filesystem_get_mount_handler>
40004d30: 90 10 00 1a mov %i2, %o0
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
40004d34: a2 92 20 00 orcc %o0, 0, %l1
40004d38: 02 80 00 ad be 40004fec <mount+0x2d0>
<== NEVER TAKEN
40004d3c: 80 a6 60 00 cmp %i1, 0
const char *target = target_or_null != NULL ? target_or_null : "/";
40004d40: 02 80 00 78 be 40004f20 <mount+0x204>
<== ALWAYS TAKEN
40004d44: 90 10 00 19 mov %i1, %o0
40004d48: 40 00 2a 7d call 4000f73c <strlen>
<== NOT EXECUTED
40004d4c: a6 10 00 19 mov %i1, %l3
<== NOT EXECUTED
40004d50: a4 02 20 01 add %o0, 1, %l2
<== NOT EXECUTED
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
40004d54: 40 00 2a 7a call 4000f73c <strlen>
40004d58: 90 10 00 1a mov %i2, %o0
strlen( source_or_null ) + 1 : 0;
40004d5c: 80 a6 20 00 cmp %i0, 0
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
40004d60: a8 02 20 01 add %o0, 1, %l4
strlen( source_or_null ) + 1 : 0;
40004d64: 02 80 00 61 be 40004ee8 <mount+0x1cc>
<== ALWAYS TAKEN
40004d68: ba 02 20 65 add %o0, 0x65, %i5
40004d6c: 40 00 2a 74 call 4000f73c <strlen>
<== NOT EXECUTED
40004d70: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
40004d74: 92 07 40 12 add %i5, %l2, %o1
<== NOT EXECUTED
strlen( source_or_null ) + 1 : 0;
40004d78: a0 02 20 01 add %o0, 1, %l0
<== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
40004d7c: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
40004d80: 7f ff fe 31 call 40004644 <calloc>
<== NOT EXECUTED
40004d84: 92 02 40 10 add %o1, %l0, %o1
<== NOT EXECUTED
if ( mt_entry != NULL ) {
40004d88: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
40004d8c: 12 80 00 08 bne 40004dac <mount+0x90>
<== NOT EXECUTED
40004d90: 84 07 60 64 add %i5, 0x64, %g2
<== NOT EXECUTED
if ( rv != 0 ) {
free( mt_entry );
}
} else {
errno = ENOMEM;
40004d94: 40 00 29 1a call 4000f1fc <__errno>
<== NOT EXECUTED
40004d98: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004d9c: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40004da0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004da4: 81 c7 e0 08 ret
<== NOT EXECUTED
40004da8: 81 e8 00 00 restore
<== NOT EXECUTED
memcpy( str, filesystemtype, filesystemtype_size );
40004dac: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
40004db0: 94 10 00 14 mov %l4, %o2
<== NOT EXECUTED
40004db4: 40 00 29 40 call 4000f2b4 <memcpy>
<== NOT EXECUTED
40004db8: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
mt_entry->type = str;
40004dbc: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
<== NOT EXECUTED
str += filesystemtype_size;
40004dc0: 84 02 00 14 add %o0, %l4, %g2
<== NOT EXECUTED
memcpy( str, source_or_null, source_size );
40004dc4: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
40004dc8: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40004dcc: 40 00 29 3a call 4000f2b4 <memcpy>
<== NOT EXECUTED
40004dd0: 90 10 00 02 mov %g2, %o0
<== NOT EXECUTED
mt_entry->dev = str;
40004dd4: d0 27 60 38 st %o0, [ %i5 + 0x38 ]
<== NOT EXECUTED
rtems_filesystem_global_location_t *mt_fs_root =
40004dd8: b4 07 60 40 add %i5, 0x40, %i2
<== NOT EXECUTED
str += source_size;
40004ddc: a0 02 00 10 add %o0, %l0, %l0
<== NOT EXECUTED
memcpy( str, target, target_size );
40004de0: 94 10 00 12 mov %l2, %o2
40004de4: 92 10 00 13 mov %l3, %o1
40004de8: 40 00 29 33 call 4000f2b4 <memcpy>
40004dec: 90 10 00 10 mov %l0, %o0
mt_entry->mounted = true;
40004df0: 82 10 20 01 mov 1, %g1
40004df4: c2 2f 60 28 stb %g1, [ %i5 + 0x28 ]
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
40004df8: 03 10 00 43 sethi %hi(0x40010c00), %g1
40004dfc: 82 10 60 98 or %g1, 0x98, %g1 ! 40010c98 <rtems_filesystem_default_pathconf>
mt_entry->target = str;
40004e00: e0 27 60 30 st %l0, [ %i5 + 0x30 ]
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
_Chain_Initialize(
40004e04: 96 10 20 24 mov 0x24, %o3
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
40004e08: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
mt_fs_root->reference_count = 1;
40004e0c: 82 10 20 01 mov 1, %g1
mt_entry->mt_fs_root = mt_fs_root;
40004e10: f4 27 60 24 st %i2, [ %i5 + 0x24 ]
40004e14: 94 10 20 01 mov 1, %o2
mt_fs_root->reference_count = 1;
40004e18: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
40004e1c: 92 10 00 1a mov %i2, %o1
mt_fs_root->location.mt_entry = mt_entry;
40004e20: fa 27 60 54 st %i5, [ %i5 + 0x54 ]
40004e24: 90 07 60 14 add %i5, 0x14, %o0
40004e28: 40 00 0a b6 call 40007900 <_Chain_Initialize>
40004e2c: b6 0e e0 01 and %i3, 1, %i3
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
40004e30: f6 2f 60 29 stb %i3, [ %i5 + 0x29 ]
rv = (*fsmount_me_h)( mt_entry, data );
40004e34: 92 10 00 1c mov %i4, %o1
40004e38: 9f c4 40 00 call %l1
40004e3c: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40004e40: b0 92 20 00 orcc %o0, 0, %i0
40004e44: 12 80 00 25 bne 40004ed8 <mount+0x1bc>
<== NEVER TAKEN
40004e48: 80 a6 60 00 cmp %i1, 0
if ( target != NULL ) {
40004e4c: 02 80 00 48 be 40004f6c <mount+0x250>
<== ALWAYS TAKEN
40004e50: 94 10 20 1f mov 0x1f, %o2
rtems_filesystem_location_info_t *currentloc =
40004e54: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
40004e58: 40 00 03 02 call 40005a60 <rtems_filesystem_eval_path_start>
<== NOT EXECUTED
40004e5c: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40004e60: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
return (*mt_entry->ops->are_nodes_equal_h)(
40004e64: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
40004e68: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
<== NOT EXECUTED
40004e6c: 9f c0 80 00 call %g2
<== NOT EXECUTED
40004e70: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
<== NOT EXECUTED
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
40004e74: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40004e78: 12 80 00 63 bne 40005004 <mount+0x2e8>
<== NOT EXECUTED
40004e7c: 92 07 bf e0 add %fp, -32, %o1
<== NOT EXECUTED
rtems_filesystem_location_copy_and_detach(
40004e80: 40 00 04 4e call 40005fb8 <rtems_filesystem_location_copy_and_detach>
<== NOT EXECUTED
40004e84: 90 07 bf b0 add %fp, -80, %o0
<== NOT EXECUTED
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
40004e88: 40 00 04 77 call 40006064 <rtems_filesystem_location_transform_to_global>
<== NOT EXECUTED
40004e8c: 90 07 bf b0 add %fp, -80, %o0
<== NOT EXECUTED
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40004e90: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
40004e94: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
mt_entry->mt_point_node = mt_point_node;
40004e98: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
<== NOT EXECUTED
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
40004e9c: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40004ea0: c2 00 60 2c ld [ %g1 + 0x2c ], %g1
<== NOT EXECUTED
40004ea4: 9f c0 40 00 call %g1
<== NOT EXECUTED
40004ea8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if ( rv == 0 ) {
40004eac: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
40004eb0: 02 80 00 20 be 40004f30 <mount+0x214>
<== NOT EXECUTED
40004eb4: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
rtems_filesystem_global_location_release( mt_point_node, true );
40004eb8: 40 00 03 fb call 40005ea4 <rtems_filesystem_global_location_release>
<== NOT EXECUTED
40004ebc: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
40004ec0: 40 00 02 f4 call 40005a90 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
40004ec4: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40004ec8: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
40004ecc: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
<== NOT EXECUTED
40004ed0: 9f c0 40 00 call %g1
<== NOT EXECUTED
40004ed4: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
free( mt_entry );
40004ed8: 7f ff fe 26 call 40004770 <free>
<== NOT EXECUTED
40004edc: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
errno = EINVAL;
rv = -1;
}
return rv;
}
40004ee0: 81 c7 e0 08 ret
<== NOT EXECUTED
40004ee4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
40004ee8: 92 07 40 12 add %i5, %l2, %o1
40004eec: 7f ff fd d6 call 40004644 <calloc>
40004ef0: 90 10 20 01 mov 1, %o0
if ( mt_entry != NULL ) {
40004ef4: ba 92 20 00 orcc %o0, 0, %i5
40004ef8: 02 bf ff a7 be 40004d94 <mount+0x78>
<== NEVER TAKEN
40004efc: 84 07 60 64 add %i5, 0x64, %g2
memcpy( str, filesystemtype, filesystemtype_size );
40004f00: 92 10 00 1a mov %i2, %o1
40004f04: 94 10 00 14 mov %l4, %o2
40004f08: 90 10 00 02 mov %g2, %o0
40004f0c: 40 00 28 ea call 4000f2b4 <memcpy>
40004f10: b4 07 60 40 add %i5, 0x40, %i2
str += filesystemtype_size;
40004f14: a0 02 00 14 add %o0, %l4, %l0
mt_entry->type = str;
40004f18: 10 bf ff b2 b 40004de0 <mount+0xc4>
40004f1c: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
const char *target = target_or_null != NULL ? target_or_null : "/";
40004f20: 27 10 00 42 sethi %hi(0x40010800), %l3
40004f24: a4 10 20 02 mov 2, %l2
40004f28: 10 bf ff 8b b 40004d54 <mount+0x38>
40004f2c: a6 14 e0 d0 or %l3, 0xd0, %l3
rtems_libio_lock();
40004f30: 7f ff fe 84 call 40004940 <rtems_libio_lock>
<== NOT EXECUTED
40004f34: 01 00 00 00 nop
<== NOT EXECUTED
old_last = tail->previous;
40004f38: 03 10 00 49 sethi %hi(0x40012400), %g1
<== NOT EXECUTED
40004f3c: 82 10 62 c4 or %g1, 0x2c4, %g1 ! 400126c4 <rtems_filesystem_mount_table>
<== NOT EXECUTED
40004f40: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
the_node->next = tail;
40004f44: 86 00 60 04 add %g1, 4, %g3
<== NOT EXECUTED
tail->previous = the_node;
40004f48: fa 20 60 08 st %i5, [ %g1 + 8 ]
<== NOT EXECUTED
the_node->next = tail;
40004f4c: c6 27 40 00 st %g3, [ %i5 ]
<== NOT EXECUTED
old_last->next = the_node;
40004f50: fa 20 80 00 st %i5, [ %g2 ]
<== NOT EXECUTED
rtems_libio_unlock();
40004f54: 7f ff fe 80 call 40004954 <rtems_libio_unlock>
<== NOT EXECUTED
40004f58: c4 27 60 04 st %g2, [ %i5 + 4 ]
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
40004f5c: 40 00 02 cd call 40005a90 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
40004f60: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
40004f64: 81 c7 e0 08 ret
<== NOT EXECUTED
40004f68: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_libio_lock();
40004f6c: 7f ff fe 75 call 40004940 <rtems_libio_lock>
40004f70: 01 00 00 00 nop
return _Chain_Immutable_head( the_chain )->next;
40004f74: 03 10 00 49 sethi %hi(0x40012400), %g1
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
40004f78: c4 00 62 c4 ld [ %g1 + 0x2c4 ], %g2 ! 400126c4 <rtems_filesystem_mount_table>
40004f7c: 82 10 62 c4 or %g1, 0x2c4, %g1
40004f80: 86 00 60 04 add %g1, 4, %g3
40004f84: 80 a0 80 03 cmp %g2, %g3
40004f88: 12 80 00 27 bne 40005024 <mount+0x308>
<== NEVER TAKEN
40004f8c: 01 00 00 00 nop
old_last = tail->previous;
40004f90: c6 00 60 08 ld [ %g1 + 8 ], %g3
the_node->next = tail;
40004f94: c4 27 40 00 st %g2, [ %i5 ]
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
40004f98: b8 07 60 24 add %i5, 0x24, %i4
tail->previous = the_node;
40004f9c: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
40004fa0: fa 20 c0 00 st %i5, [ %g3 ]
rtems_libio_unlock();
40004fa4: 7f ff fe 6c call 40004954 <rtems_libio_unlock>
40004fa8: c6 27 60 04 st %g3, [ %i5 + 4 ]
rtems_filesystem_global_location_t *new_fs_root =
40004fac: 40 00 03 84 call 40005dbc <rtems_filesystem_global_location_obtain>
40004fb0: 90 10 00 1c mov %i4, %o0
40004fb4: b6 10 00 08 mov %o0, %i3
rtems_filesystem_global_location_t *new_fs_current =
40004fb8: 40 00 03 81 call 40005dbc <rtems_filesystem_global_location_obtain>
40004fbc: 90 10 00 1c mov %i4, %o0
&rtems_filesystem_root,
40004fc0: 40 00 00 fa call 400053a8 <rtems_current_user_env_get>
40004fc4: ba 10 00 08 mov %o0, %i5
rtems_filesystem_global_location_assign(
40004fc8: 92 10 00 1b mov %i3, %o1
40004fcc: 40 00 03 d0 call 40005f0c <rtems_filesystem_global_location_assign>
40004fd0: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_current,
40004fd4: 40 00 00 f5 call 400053a8 <rtems_current_user_env_get>
40004fd8: 01 00 00 00 nop
rtems_filesystem_global_location_assign(
40004fdc: 40 00 03 cc call 40005f0c <rtems_filesystem_global_location_assign>
40004fe0: 92 10 00 1d mov %i5, %o1
40004fe4: 81 c7 e0 08 ret
40004fe8: 81 e8 00 00 restore
errno = EINVAL;
40004fec: 40 00 28 84 call 4000f1fc <__errno>
<== NOT EXECUTED
40004ff0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004ff4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40004ff8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return rv;
40004ffc: 81 c7 e0 08 ret
<== NOT EXECUTED
40005000: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_eval_path_error( &ctx, EBUSY );
40005004: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
40005008: 40 00 01 db call 40005774 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
4000500c: 92 10 20 10 mov 0x10, %o1
<== NOT EXECUTED
rv = -1;
40005010: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
40005014: 40 00 02 9f call 40005a90 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
40005018: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
4000501c: 10 bf ff ac b 40004ecc <mount+0x1b0>
<== NOT EXECUTED
40005020: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
errno = EINVAL;
40005024: 40 00 28 76 call 4000f1fc <__errno>
<== NOT EXECUTED
40005028: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000502c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40005030: 7f ff fe 49 call 40004954 <rtems_libio_unlock>
<== NOT EXECUTED
40005034: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40005038: 10 bf ff a5 b 40004ecc <mount+0x1b0>
<== NOT EXECUTED
4000503c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
4000513c <open>:
/**
* POSIX 1003.1 5.3.1 - Open a File
*/
int open( const char *path, int oflag, ... )
{
4000513c: 9d e3 bf 00 save %sp, -256, %sp
mode_t mode = 0;
rtems_libio_t *iop = NULL;
va_start( ap, oflag );
mode = va_arg( ap, mode_t );
40005140: 82 07 a0 50 add %fp, 0x50, %g1
va_start( ap, oflag );
40005144: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
40005148: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
4000514c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40005150: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
iop = rtems_libio_allocate();
40005154: 40 00 24 89 call 4000e378 <rtems_libio_allocate>
40005158: c2 27 bf 64 st %g1, [ %fp + -156 ]
if ( iop != NULL ) {
4000515c: ba 92 20 00 orcc %o0, 0, %i5
40005160: 02 80 00 76 be 40005338 <open+0x1fc>
<== NEVER TAKEN
40005164: 82 06 60 01 add %i1, 1, %g1
bool make = (oflag & O_CREAT) == O_CREAT;
40005168: 86 0e 62 00 and %i1, 0x200, %g3
bool read_access = (rwflag & _FREAD) == _FREAD;
4000516c: 94 08 60 01 and %g1, 1, %o2
bool exclusive = (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL);
40005170: 84 0e 6a 00 and %i1, 0xa00, %g2
| (read_access ? RTEMS_FS_PERMS_READ : 0)
40005174: 94 02 bf ff add %o2, -1, %o2
| (write_access ? RTEMS_FS_PERMS_WRITE : 0)
40005178: b8 88 60 02 andcc %g1, 2, %i4
| (read_access ? RTEMS_FS_PERMS_READ : 0)
4000517c: 94 0a bf fc and %o2, -4, %o2
| (write_access ? RTEMS_FS_PERMS_WRITE : 0)
40005180: 02 80 00 03 be 4000518c <open+0x50>
40005184: 94 02 a0 1c add %o2, 0x1c, %o2
40005188: 94 12 a0 02 or %o2, 2, %o2
| (make ? RTEMS_FS_MAKE : 0)
4000518c: 80 a0 e0 00 cmp %g3, 0
40005190: 32 80 00 02 bne,a 40005198 <open+0x5c>
<== NEVER TAKEN
40005194: 94 12 a0 20 or %o2, 0x20, %o2
<== NOT EXECUTED
| (exclusive ? RTEMS_FS_EXCLUSIVE : 0);
40005198: 80 a0 aa 00 cmp %g2, 0xa00
4000519c: 22 80 00 02 be,a 400051a4 <open+0x68>
<== NEVER TAKEN
400051a0: 94 12 a0 40 or %o2, 0x40, %o2
<== NOT EXECUTED
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
400051a4: 92 10 00 18 mov %i0, %o1
400051a8: 40 00 02 2e call 40005a60 <rtems_filesystem_eval_path_start>
400051ac: 90 07 bf 68 add %fp, -152, %o0
400051b0: f6 07 bf 74 ld [ %fp + -140 ], %i3
if ( rtems_filesystem_eval_path_has_token( &ctx ) ) {
400051b4: 80 a6 e0 00 cmp %i3, 0
400051b8: 12 80 00 45 bne 400052cc <open+0x190>
<== NEVER TAKEN
400051bc: 80 a7 20 00 cmp %i4, 0
if ( write_access ) {
400051c0: 02 80 00 0e be 400051f8 <open+0xbc>
400051c4: c2 07 bf 90 ld [ %fp + -112 ], %g1
const rtems_filesystem_location_info_t *loc
)
{
struct stat st;
st.st_mode = 0;
400051c8: c0 27 bf ac clr [ %fp + -84 ]
(void) ( *loc->handlers->fstat_h )( loc, &st );
400051cc: 92 07 bf a0 add %fp, -96, %o1
400051d0: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
400051d4: 9f c0 40 00 call %g1
400051d8: 90 07 bf 80 add %fp, -128, %o0
if ( S_ISDIR( type ) ) {
400051dc: 05 00 00 3c sethi %hi(0xf000), %g2
400051e0: c2 07 bf ac ld [ %fp + -84 ], %g1
400051e4: 82 08 40 02 and %g1, %g2, %g1
400051e8: 05 00 00 10 sethi %hi(0x4000), %g2
400051ec: 80 a0 40 02 cmp %g1, %g2
400051f0: 02 80 00 4e be 40005328 <open+0x1ec>
<== NEVER TAKEN
400051f4: 92 10 20 15 mov 0x15, %o1
rtems_filesystem_location_copy_and_detach(
400051f8: 92 07 bf 80 add %fp, -128, %o1
400051fc: 40 00 03 6f call 40005fb8 <rtems_filesystem_location_copy_and_detach>
40005200: 90 07 60 0c add %i5, 0xc, %o0
rtems_filesystem_eval_path_cleanup( &ctx );
40005204: 40 00 02 23 call 40005a90 <rtems_filesystem_eval_path_cleanup>
40005208: 90 07 bf 68 add %fp, -152, %o0
_Atomic_Store_uint(
4000520c: 40 00 24 4e call 4000e344 <rtems_libio_fcntl_flags>
40005210: 90 10 00 19 mov %i1, %o0
rv = (*iop->pathinfo.handlers->open_h)( iop, path, oflag, mode );
40005214: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
#elif defined(_RTEMS_SCORE_CPUSTDATOMIC_USE_STDATOMIC)
atomic_store_explicit( obj, desired, order );
#else
(void) order;
RTEMS_COMPILER_MEMORY_BARRIER();
*obj = desired;
40005218: d0 27 60 08 st %o0, [ %i5 + 8 ]
4000521c: 92 10 00 18 mov %i0, %o1
40005220: c2 00 40 00 ld [ %g1 ], %g1
40005224: 96 10 00 1a mov %i2, %o3
40005228: 94 10 00 19 mov %i1, %o2
4000522c: 9f c0 40 00 call %g1
40005230: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40005234: b0 92 20 00 orcc %o0, 0, %i0
40005238: 12 80 00 13 bne 40005284 <open+0x148>
<== NEVER TAKEN
4000523c: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
int fd = rtems_libio_iop_to_descriptor( iop );
40005240: 31 10 00 4e sethi %hi(0x40013800), %i0
<== NOT EXECUTED
40005244: 03 2a aa aa sethi %hi(0xaaaaa800), %g1
<== NOT EXECUTED
40005248: b0 16 21 a8 or %i0, 0x1a8, %i0
<== NOT EXECUTED
4000524c: 82 10 62 ab or %g1, 0x2ab, %g1
<== NOT EXECUTED
40005250: b0 27 40 18 sub %i5, %i0, %i0
<== NOT EXECUTED
40005254: b1 3e 20 04 sra %i0, 4, %i0
<== NOT EXECUTED
40005258: b0 5e 00 01 smul %i0, %g1, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000525c: 91 d0 20 09 ta 9
<== NOT EXECUTED
ISR_Level level;
(void) order;
_ISR_Local_disable( level );
val = *obj;
*obj = val | arg;
40005260: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005264: 84 10 a1 00 or %g2, 0x100, %g2
<== NOT EXECUTED
40005268: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000526c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005270: 01 00 00 00 nop
if ( truncate ) {
40005274: 80 8e 64 00 btst 0x400, %i1
40005278: 12 80 00 07 bne 40005294 <open+0x158>
<== NEVER TAKEN
4000527c: 92 10 20 00 clr %o1
if ( rv < 0 ) {
40005280: 80 a6 20 00 cmp %i0, 0
40005284: 06 80 00 0e bl 400052bc <open+0x180>
<== NEVER TAKEN
40005288: 01 00 00 00 nop
}
va_end( ap );
return rv;
}
4000528c: 81 c7 e0 08 ret
40005290: 81 e8 00 00 restore
rv = ftruncate( fd, 0 );
40005294: 94 10 20 00 clr %o2
<== NOT EXECUTED
40005298: 40 00 23 e2 call 4000e220 <ftruncate>
<== NOT EXECUTED
4000529c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if ( rv != 0 ) {
400052a0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400052a4: 02 bf ff f7 be 40005280 <open+0x144>
<== NOT EXECUTED
400052a8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
(*iop->pathinfo.handlers->close_h)( iop );
400052ac: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
400052b0: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
400052b4: 9f c0 40 00 call %g1
<== NOT EXECUTED
400052b8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_libio_free( iop );
400052bc: 40 00 24 44 call 4000e3cc <rtems_libio_free>
<== NOT EXECUTED
400052c0: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
400052c4: 81 c7 e0 08 ret
<== NOT EXECUTED
400052c8: 81 e8 00 00 restore
<== NOT EXECUTED
400052cc: e0 07 bf 70 ld [ %fp + -144 ], %l0
<== NOT EXECUTED
rv = rtems_filesystem_mknod(
400052d0: 98 10 20 00 clr %o4
<== NOT EXECUTED
400052d4: 9a 10 20 00 clr %o5
<== NOT EXECUTED
400052d8: 17 00 00 20 sethi %hi(0x8000), %o3
<== NOT EXECUTED
400052dc: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
400052e0: 96 16 80 0b or %i2, %o3, %o3
<== NOT EXECUTED
400052e4: 92 10 00 10 mov %l0, %o1
<== NOT EXECUTED
400052e8: 7f ff fe 4c call 40004c18 <rtems_filesystem_mknod>
<== NOT EXECUTED
400052ec: 90 07 bf 80 add %fp, -128, %o0
<== NOT EXECUTED
if ( rv == 0 ) {
400052f0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400052f4: 02 80 00 06 be 4000530c <open+0x1d0>
<== NOT EXECUTED
400052f8: 92 10 20 00 clr %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_error( ctx, 0 );
400052fc: 40 00 01 1e call 40005774 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005300: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
if ( write_access ) {
40005304: 10 bf ff af b 400051c0 <open+0x84>
<== NOT EXECUTED
40005308: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
ctx->flags = flags;
4000530c: c0 27 bf 78 clr [ %fp + -136 ]
<== NOT EXECUTED
rtems_filesystem_eval_path_continue( ctx );
40005310: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
ctx->path = path;
40005314: e0 27 bf 68 st %l0, [ %fp + -152 ]
<== NOT EXECUTED
40005318: 40 00 01 5f call 40005894 <rtems_filesystem_eval_path_continue>
<== NOT EXECUTED
4000531c: f6 27 bf 6c st %i3, [ %fp + -148 ]
<== NOT EXECUTED
if ( write_access ) {
40005320: 10 bf ff a8 b 400051c0 <open+0x84>
<== NOT EXECUTED
40005324: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
rtems_filesystem_eval_path_error( &ctx, EISDIR );
40005328: 40 00 01 13 call 40005774 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
4000532c: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
rtems_filesystem_location_copy_and_detach(
40005330: 10 bf ff b3 b 400051fc <open+0xc0>
<== NOT EXECUTED
40005334: 92 07 bf 80 add %fp, -128, %o1
<== NOT EXECUTED
errno = ENFILE;
40005338: 40 00 27 b1 call 4000f1fc <__errno>
<== NOT EXECUTED
4000533c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005340: 82 10 20 17 mov 0x17, %g1
<== NOT EXECUTED
40005344: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40005348: 81 c7 e0 08 ret
<== NOT EXECUTED
4000534c: 81 e8 00 00 restore
<== NOT EXECUTED
40005350 <printk>:
/**
* Kernel printf function requiring minimal infrastructure.
*/
int printk(const char *fmt, ...)
{
40005350: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
va_list ap; /* points to each unnamed argument in turn */
int len;
va_start(ap, fmt); /* make ap point to 1st unnamed arg */
40005354: 82 07 a0 48 add %fp, 0x48, %g1
<== NOT EXECUTED
40005358: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
<== NOT EXECUTED
len = vprintk(fmt, ap);
4000535c: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
va_start(ap, fmt); /* make ap point to 1st unnamed arg */
40005360: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
<== NOT EXECUTED
len = vprintk(fmt, ap);
40005364: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
va_start(ap, fmt); /* make ap point to 1st unnamed arg */
40005368: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
<== NOT EXECUTED
4000536c: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
<== NOT EXECUTED
40005370: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
<== NOT EXECUTED
len = vprintk(fmt, ap);
40005374: 40 00 03 e6 call 4000630c <vprintk>
<== NOT EXECUTED
40005378: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
va_end(ap); /* clean up when done */
return len;
}
4000537c: 81 c7 e0 08 ret
<== NOT EXECUTED
40005380: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000f054 <rtems_assoc_local_by_remote>:
uint32_t rtems_assoc_local_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000f054: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_remote(ap, remote_value);
4000f058: 90 10 00 18 mov %i0, %o0
4000f05c: 92 10 00 19 mov %i1, %o1
4000f060: 40 00 00 07 call 4000f07c <rtems_assoc_ptr_by_remote>
4000f064: b0 10 20 00 clr %i0
if (nap)
4000f068: 80 a2 20 00 cmp %o0, 0
4000f06c: 32 80 00 02 bne,a 4000f074 <rtems_assoc_local_by_remote+0x20>
<== ALWAYS TAKEN
4000f070: f0 02 20 04 ld [ %o0 + 4 ], %i0
return nap->local_value;
return 0;
}
4000f074: 81 c7 e0 08 ret
4000f078: 81 e8 00 00 restore
4000f008 <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000f008: 9d e3 bf a0 save %sp, -96, %sp
4000f00c: b8 10 20 20 mov 0x20, %i4
uint32_t b;
uint32_t local_value = 0;
4000f010: b6 10 20 00 clr %i3
for (b = 1; b; b <<= 1) {
4000f014: 10 80 00 04 b 4000f024 <rtems_assoc_local_by_remote_bitfield+0x1c>
4000f018: ba 10 20 01 mov 1, %i5
4000f01c: 02 80 00 0c be 4000f04c <rtems_assoc_local_by_remote_bitfield+0x44>
4000f020: bb 2f 60 01 sll %i5, 1, %i5
if (b & remote_value)
4000f024: 80 8e 40 1d btst %i1, %i5
4000f028: 22 bf ff fd be,a 4000f01c <rtems_assoc_local_by_remote_bitfield+0x14>
<== ALWAYS TAKEN
4000f02c: b8 87 3f ff addcc %i4, -1, %i4
local_value |= rtems_assoc_local_by_remote(ap, b);
4000f030: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
4000f034: 40 00 00 08 call 4000f054 <rtems_assoc_local_by_remote>
<== NOT EXECUTED
4000f038: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
for (b = 1; b; b <<= 1) {
4000f03c: bb 2f 60 01 sll %i5, 1, %i5
<== NOT EXECUTED
4000f040: b8 87 3f ff addcc %i4, -1, %i4
<== NOT EXECUTED
4000f044: 12 bf ff f8 bne 4000f024 <rtems_assoc_local_by_remote_bitfield+0x1c>
<== NOT EXECUTED
4000f048: b6 16 c0 08 or %i3, %o0, %i3
<== NOT EXECUTED
}
return local_value;
}
4000f04c: 81 c7 e0 08 ret
4000f050: 91 e8 00 1b restore %g0, %i3, %o0
4000f07c <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4000f07c: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
4000f080: d0 06 00 00 ld [ %i0 ], %o0
{
4000f084: ba 10 00 18 mov %i0, %i5
if (rtems_assoc_is_default(ap))
4000f088: 80 a2 20 00 cmp %o0, 0
4000f08c: 02 80 00 16 be 4000f0e4 <rtems_assoc_ptr_by_remote+0x68>
<== NEVER TAKEN
4000f090: b0 10 20 00 clr %i0
4000f094: 13 10 00 45 sethi %hi(0x40011400), %o1
4000f098: 40 00 01 4e call 4000f5d0 <strcmp>
4000f09c: 92 12 60 58 or %o1, 0x58, %o1 ! 40011458 <CSWTCH.1+0x10>
4000f0a0: 80 a2 20 00 cmp %o0, 0
4000f0a4: 22 80 00 12 be,a 4000f0ec <rtems_assoc_ptr_by_remote+0x70>
<== NEVER TAKEN
4000f0a8: c4 07 60 0c ld [ %i5 + 0xc ], %g2
<== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
4000f0ac: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000f0b0: 80 a6 40 01 cmp %i1, %g1
4000f0b4: 32 80 00 08 bne,a 4000f0d4 <rtems_assoc_ptr_by_remote+0x58>
4000f0b8: ba 07 60 0c add %i5, 0xc, %i5
for ( ; ap->name; ap++)
4000f0bc: 81 c7 e0 08 ret
4000f0c0: 91 e8 00 1d restore %g0, %i5, %o0
if (ap->remote_value == remote_value)
4000f0c4: 80 a0 40 19 cmp %g1, %i1
4000f0c8: 22 80 00 07 be,a 4000f0e4 <rtems_assoc_ptr_by_remote+0x68>
<== ALWAYS TAKEN
4000f0cc: b0 10 00 1d mov %i5, %i0
for ( ; ap->name; ap++)
4000f0d0: ba 07 60 0c add %i5, 0xc, %i5
<== NOT EXECUTED
4000f0d4: c2 07 40 00 ld [ %i5 ], %g1
4000f0d8: 80 a0 60 00 cmp %g1, 0
4000f0dc: 32 bf ff fa bne,a 4000f0c4 <rtems_assoc_ptr_by_remote+0x48>
<== ALWAYS TAKEN
4000f0e0: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000f0e4: 81 c7 e0 08 ret
4000f0e8: 81 e8 00 00 restore
default_ap = ap++;
4000f0ec: 82 07 60 0c add %i5, 0xc, %g1
<== NOT EXECUTED
for ( ; ap->name; ap++)
4000f0f0: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
4000f0f4: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
4000f0f8: 12 bf ff ed bne 4000f0ac <rtems_assoc_ptr_by_remote+0x30>
<== NOT EXECUTED
4000f0fc: ba 10 00 01 mov %g1, %i5
<== NOT EXECUTED
4000f100: 81 c7 e0 08 ret
<== NOT EXECUTED
4000f104: 81 e8 00 00 restore
<== NOT EXECUTED
400053a8 <rtems_current_user_env_get>:
{
400053a8: 9d e3 bf a0 save %sp, -96, %sp
void *ptr = pthread_getspecific(rtems_current_user_env_key);
400053ac: 03 10 00 4f sethi %hi(0x40013c00), %g1
400053b0: 40 00 03 fb call 4000639c <pthread_getspecific>
400053b4: d0 00 61 60 ld [ %g1 + 0x160 ], %o0 ! 40013d60 <rtems_current_user_env_key>
if (ptr == NULL) {
400053b8: b0 92 20 00 orcc %o0, 0, %i0
400053bc: 22 80 00 04 be,a 400053cc <rtems_current_user_env_get+0x24>
<== ALWAYS TAKEN
400053c0: 31 10 00 49 sethi %hi(0x40012400), %i0
}
400053c4: 81 c7 e0 08 ret
<== NOT EXECUTED
400053c8: 81 e8 00 00 restore
<== NOT EXECUTED
400053cc: 81 c7 e0 08 ret
400053d0: 91 ee 22 d0 restore %i0, 0x2d0, %o0
4000e604 <rtems_deviceio_close>:
int rtems_deviceio_close(
rtems_libio_t *iop,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000e604: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
args.iop = iop;
args.flags = 0;
args.mode = 0;
status = rtems_io_close( major, minor, &args );
4000e608: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
4000e60c: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
args.iop = iop;
4000e610: f0 27 bf f4 st %i0, [ %fp + -12 ]
<== NOT EXECUTED
status = rtems_io_close( major, minor, &args );
4000e614: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
args.flags = 0;
4000e618: c0 27 bf f8 clr [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_close( major, minor, &args );
4000e61c: 40 00 00 cd call 4000e950 <rtems_io_close>
<== NOT EXECUTED
4000e620: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
return rtems_status_code_to_errno( status );
4000e624: 40 00 00 b5 call 4000e8f8 <rtems_status_code_to_errno>
<== NOT EXECUTED
4000e628: 01 00 00 00 nop
<== NOT EXECUTED
}
4000e62c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e630: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e714 <rtems_deviceio_control>:
ioctl_command_t command,
void *buffer,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000e714: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
rtems_status_code status;
rtems_libio_ioctl_args_t args;
args.iop = iop;
4000e718: f0 27 bf f0 st %i0, [ %fp + -16 ]
<== NOT EXECUTED
args.command = command;
args.buffer = buffer;
status = rtems_io_control( major, minor, &args );
4000e71c: 94 07 bf f0 add %fp, -16, %o2
<== NOT EXECUTED
args.command = command;
4000e720: f2 27 bf f4 st %i1, [ %fp + -12 ]
<== NOT EXECUTED
status = rtems_io_control( major, minor, &args );
4000e724: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
args.buffer = buffer;
4000e728: f4 27 bf f8 st %i2, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_control( major, minor, &args );
4000e72c: 40 00 00 a1 call 4000e9b0 <rtems_io_control>
<== NOT EXECUTED
4000e730: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
4000e734: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e738: 12 80 00 05 bne 4000e74c <rtems_deviceio_control+0x38>
<== NOT EXECUTED
4000e73c: 01 00 00 00 nop
<== NOT EXECUTED
return args.ioctl_return;
4000e740: f0 07 bf fc ld [ %fp + -4 ], %i0
<== NOT EXECUTED
4000e744: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e748: 81 e8 00 00 restore
<== NOT EXECUTED
} else {
return rtems_status_code_to_errno(status);
4000e74c: 40 00 00 6b call 4000e8f8 <rtems_status_code_to_errno>
<== NOT EXECUTED
4000e750: 01 00 00 00 nop
<== NOT EXECUTED
}
}
4000e754: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e758: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e5d0 <rtems_deviceio_open>:
int oflag,
mode_t mode,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000e5d0: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
rtems_status_code status;
rtems_libio_open_close_args_t args;
args.iop = iop;
args.flags = iop->flags;
4000e5d4: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
args.mode = mode;
status = rtems_io_open( major, minor, &args );
4000e5d8: 94 07 bf f4 add %fp, -12, %o2
<== NOT EXECUTED
4000e5dc: 92 10 00 1d mov %i5, %o1
<== NOT EXECUTED
args.iop = iop;
4000e5e0: f0 27 bf f4 st %i0, [ %fp + -12 ]
<== NOT EXECUTED
status = rtems_io_open( major, minor, &args );
4000e5e4: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
args.flags = iop->flags;
4000e5e8: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_open( major, minor, &args );
4000e5ec: 40 00 01 20 call 4000ea6c <rtems_io_open>
<== NOT EXECUTED
4000e5f0: f6 27 bf fc st %i3, [ %fp + -4 ]
<== NOT EXECUTED
return rtems_status_code_to_errno( status );
4000e5f4: 40 00 00 c1 call 4000e8f8 <rtems_status_code_to_errno>
<== NOT EXECUTED
4000e5f8: 01 00 00 00 nop
<== NOT EXECUTED
}
4000e5fc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e600: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e634 <rtems_deviceio_read>:
void *buf,
size_t nbyte,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000e634: 9d e3 bf 80 save %sp, -128, %sp
<== NOT EXECUTED
rtems_status_code status;
rtems_libio_rw_args_t args;
args.iop = iop;
args.offset = iop->offset;
4000e638: c4 1e 00 00 ldd [ %i0 ], %g2
<== NOT EXECUTED
args.buffer = buf;
args.count = nbyte;
args.flags = iop->flags;
4000e63c: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
args.iop = iop;
4000e640: f0 27 bf e0 st %i0, [ %fp + -32 ]
<== NOT EXECUTED
args.bytes_moved = 0;
status = rtems_io_read( major, minor, &args );
4000e644: 94 07 bf e0 add %fp, -32, %o2
<== NOT EXECUTED
args.offset = iop->offset;
4000e648: c4 3f bf e8 std %g2, [ %fp + -24 ]
<== NOT EXECUTED
status = rtems_io_read( major, minor, &args );
4000e64c: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
args.buffer = buf;
4000e650: f2 27 bf f0 st %i1, [ %fp + -16 ]
<== NOT EXECUTED
status = rtems_io_read( major, minor, &args );
4000e654: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
args.count = nbyte;
4000e658: f4 27 bf f4 st %i2, [ %fp + -12 ]
<== NOT EXECUTED
{
4000e65c: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
args.flags = iop->flags;
4000e660: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_read( major, minor, &args );
4000e664: 40 00 01 1a call 4000eacc <rtems_io_read>
<== NOT EXECUTED
4000e668: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
4000e66c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e670: 12 80 00 09 bne 4000e694 <rtems_deviceio_read+0x60>
<== NOT EXECUTED
4000e674: 01 00 00 00 nop
<== NOT EXECUTED
iop->offset += args.bytes_moved;
4000e678: f4 1f 40 00 ldd [ %i5 ], %i2
<== NOT EXECUTED
4000e67c: f0 07 bf fc ld [ %fp + -4 ], %i0
<== NOT EXECUTED
4000e680: 86 86 c0 18 addcc %i3, %i0, %g3
<== NOT EXECUTED
4000e684: 84 46 a0 00 addx %i2, 0, %g2
<== NOT EXECUTED
4000e688: c4 3f 40 00 std %g2, [ %i5 ]
<== NOT EXECUTED
return (ssize_t) args.bytes_moved;
4000e68c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e690: 81 e8 00 00 restore
<== NOT EXECUTED
} else {
return rtems_status_code_to_errno( status );
4000e694: 40 00 00 99 call 4000e8f8 <rtems_status_code_to_errno>
<== NOT EXECUTED
4000e698: 01 00 00 00 nop
<== NOT EXECUTED
}
}
4000e69c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e6a0: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
4000e6a4 <rtems_deviceio_write>:
const void *buf,
size_t nbyte,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
4000e6a4: 9d e3 bf 80 save %sp, -128, %sp
<== NOT EXECUTED
rtems_status_code status;
rtems_libio_rw_args_t args;
args.iop = iop;
args.offset = iop->offset;
4000e6a8: c4 1e 00 00 ldd [ %i0 ], %g2
<== NOT EXECUTED
args.buffer = RTEMS_DECONST( void *, buf );
args.count = nbyte;
args.flags = iop->flags;
4000e6ac: c2 06 20 08 ld [ %i0 + 8 ], %g1
<== NOT EXECUTED
args.iop = iop;
4000e6b0: f0 27 bf e0 st %i0, [ %fp + -32 ]
<== NOT EXECUTED
args.bytes_moved = 0;
status = rtems_io_write( major, minor, &args );
4000e6b4: 94 07 bf e0 add %fp, -32, %o2
<== NOT EXECUTED
args.offset = iop->offset;
4000e6b8: c4 3f bf e8 std %g2, [ %fp + -24 ]
<== NOT EXECUTED
status = rtems_io_write( major, minor, &args );
4000e6bc: 92 10 00 1c mov %i4, %o1
<== NOT EXECUTED
args.buffer = RTEMS_DECONST( void *, buf );
4000e6c0: f2 27 bf f0 st %i1, [ %fp + -16 ]
<== NOT EXECUTED
status = rtems_io_write( major, minor, &args );
4000e6c4: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
args.count = nbyte;
4000e6c8: f4 27 bf f4 st %i2, [ %fp + -12 ]
<== NOT EXECUTED
{
4000e6cc: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
args.flags = iop->flags;
4000e6d0: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
status = rtems_io_write( major, minor, &args );
4000e6d4: 40 00 01 16 call 4000eb2c <rtems_io_write>
<== NOT EXECUTED
4000e6d8: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
if ( status == RTEMS_SUCCESSFUL ) {
4000e6dc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e6e0: 12 80 00 09 bne 4000e704 <rtems_deviceio_write+0x60>
<== NOT EXECUTED
4000e6e4: 01 00 00 00 nop
<== NOT EXECUTED
iop->offset += args.bytes_moved;
4000e6e8: f4 1f 40 00 ldd [ %i5 ], %i2
<== NOT EXECUTED
4000e6ec: f0 07 bf fc ld [ %fp + -4 ], %i0
<== NOT EXECUTED
4000e6f0: 86 86 c0 18 addcc %i3, %i0, %g3
<== NOT EXECUTED
4000e6f4: 84 46 a0 00 addx %i2, 0, %g2
<== NOT EXECUTED
4000e6f8: c4 3f 40 00 std %g2, [ %i5 ]
<== NOT EXECUTED
return (ssize_t) args.bytes_moved;
4000e6fc: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e700: 81 e8 00 00 restore
<== NOT EXECUTED
} else {
return rtems_status_code_to_errno( status );
4000e704: 40 00 00 7d call 4000e8f8 <rtems_status_code_to_errno>
<== NOT EXECUTED
4000e708: 01 00 00 00 nop
<== NOT EXECUTED
}
}
4000e70c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000e710: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
40005434 <rtems_filesystem_check_access>:
int flags,
mode_t object_mode,
uid_t object_uid,
gid_t object_gid
)
{
40005434: 9d e3 bf a0 save %sp, -96, %sp
const rtems_user_env_t *uenv = rtems_current_user_env_get();
40005438: 7f ff ff dc call 400053a8 <rtems_current_user_env_get>
4000543c: b0 0e 20 07 and %i0, 7, %i0
mode_t access_flags = flags & RTEMS_FS_PERMS_RWX;
uid_t task_uid = uenv->euid;
if (task_uid == 0 || task_uid == object_uid) {
40005440: c2 12 20 10 lduh [ %o0 + 0x10 ], %g1
40005444: 80 a0 60 00 cmp %g1, 0
40005448: 02 80 00 24 be 400054d8 <rtems_filesystem_check_access+0xa4>
<== ALWAYS TAKEN
4000544c: 80 a0 40 1a cmp %g1, %i2
40005450: 22 80 00 23 be,a 400054dc <rtems_filesystem_check_access+0xa8>
<== NOT EXECUTED
40005454: b1 2e 20 06 sll %i0, 6, %i0
<== NOT EXECUTED
access_flags <<= RTEMS_FS_USR_SHIFT;
} else {
gid_t task_gid = uenv->egid;
if (
task_gid == 0
40005458: c2 12 20 12 lduh [ %o0 + 0x12 ], %g1
<== NOT EXECUTED
if (
4000545c: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40005460: 02 80 00 18 be 400054c0 <rtems_filesystem_check_access+0x8c>
<== NOT EXECUTED
40005464: 80 a0 40 1b cmp %g1, %i3
<== NOT EXECUTED
40005468: 22 80 00 17 be,a 400054c4 <rtems_filesystem_check_access+0x90>
<== NOT EXECUTED
4000546c: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
40005470: c6 02 20 24 ld [ %o0 + 0x24 ], %g3
<== NOT EXECUTED
40005474: 80 a0 e0 00 cmp %g3, 0
<== NOT EXECUTED
40005478: 22 80 00 14 be,a 400054c8 <rtems_filesystem_check_access+0x94>
<== NOT EXECUTED
4000547c: b0 2e 00 19 andn %i0, %i1, %i0
<== NOT EXECUTED
if (uenv->groups[i] == object_gid) {
40005480: c2 12 20 28 lduh [ %o0 + 0x28 ], %g1
<== NOT EXECUTED
40005484: 80 a0 40 1b cmp %g1, %i3
<== NOT EXECUTED
40005488: 02 80 00 0e be 400054c0 <rtems_filesystem_check_access+0x8c>
<== NOT EXECUTED
4000548c: 90 02 20 2a add %o0, 0x2a, %o0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
40005490: 10 80 00 06 b 400054a8 <rtems_filesystem_check_access+0x74>
<== NOT EXECUTED
40005494: 82 10 20 00 clr %g1
<== NOT EXECUTED
if (uenv->groups[i] == object_gid) {
40005498: c4 12 3f fe lduh [ %o0 + -2 ], %g2
<== NOT EXECUTED
4000549c: 80 a0 80 1b cmp %g2, %i3
<== NOT EXECUTED
400054a0: 22 80 00 09 be,a 400054c4 <rtems_filesystem_check_access+0x90>
<== NOT EXECUTED
400054a4: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
400054a8: 82 00 60 01 inc %g1
<== NOT EXECUTED
400054ac: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
400054b0: 12 bf ff fa bne 40005498 <rtems_filesystem_check_access+0x64>
<== NOT EXECUTED
400054b4: 90 02 20 02 add %o0, 2, %o0
<== NOT EXECUTED
} else {
access_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (access_flags & object_mode) == access_flags;
400054b8: 10 80 00 04 b 400054c8 <rtems_filesystem_check_access+0x94>
<== NOT EXECUTED
400054bc: b0 2e 00 19 andn %i0, %i1, %i0
<== NOT EXECUTED
access_flags <<= RTEMS_FS_GRP_SHIFT;
400054c0: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
return (access_flags & object_mode) == access_flags;
400054c4: b0 2e 00 19 andn %i0, %i1, %i0
<== NOT EXECUTED
}
400054c8: 80 a0 00 18 cmp %g0, %i0
<== NOT EXECUTED
400054cc: b0 60 3f ff subx %g0, -1, %i0
<== NOT EXECUTED
400054d0: 81 c7 e0 08 ret
<== NOT EXECUTED
400054d4: 81 e8 00 00 restore
<== NOT EXECUTED
access_flags <<= RTEMS_FS_USR_SHIFT;
400054d8: b1 2e 20 06 sll %i0, 6, %i0
return (access_flags & object_mode) == access_flags;
400054dc: b0 2e 00 19 andn %i0, %i1, %i0
}
400054e0: 80 a0 00 18 cmp %g0, %i0
400054e4: b0 60 3f ff subx %g0, -1, %i0
400054e8: 81 c7 e0 08 ret
400054ec: 81 e8 00 00 restore
40010c98 <rtems_filesystem_default_pathconf>:
40010c98: 00 00 00 05 00 00 00 80 00 00 00 07 00 00 00 ff ................
40010ca8: 00 00 00 ff 00 00 04 00 00 00 00 00 00 00 00 00 ................
40010cb8: 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 ................
40010cc8: 2e 00 00 00 00 00 00 00 2e 2e 00 00 ............
40005c98 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
40005c98: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_libio_lock();
40005c9c: 7f ff fb 29 call 40004940 <rtems_libio_lock>
<== NOT EXECUTED
40005ca0: 01 00 00 00 nop
<== NOT EXECUTED
next = the_node->next;
40005ca4: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
previous = the_node->previous;
40005ca8: c2 06 20 04 ld [ %i0 + 4 ], %g1
<== NOT EXECUTED
next->previous = previous;
40005cac: c2 20 a0 04 st %g1, [ %g2 + 4 ]
<== NOT EXECUTED
rtems_libio_unlock();
40005cb0: 7f ff fb 29 call 40004954 <rtems_libio_unlock>
<== NOT EXECUTED
40005cb4: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
release_with_count(global_loc, 1);
40005cb8: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
<== NOT EXECUTED
40005cbc: 40 00 00 14 call 40005d0c <release_with_count>
<== NOT EXECUTED
40005cc0: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
rtems_filesystem_mt_lock();
rtems_chain_extract_unprotected(&mt_entry->mt_node);
rtems_filesystem_mt_unlock();
rtems_filesystem_global_location_release(mt_entry->mt_point_node, false);
(*mt_entry->ops->fsunmount_me_h)(mt_entry);
40005cc4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
<== NOT EXECUTED
40005cc8: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
<== NOT EXECUTED
40005ccc: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005cd0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
if (mt_entry->unmount_task != 0) {
40005cd4: d0 06 20 3c ld [ %i0 + 0x3c ], %o0
<== NOT EXECUTED
40005cd8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005cdc: 02 80 00 07 be 40005cf8 <rtems_filesystem_do_unmount+0x60>
<== NOT EXECUTED
40005ce0: 01 00 00 00 nop
<== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_status_code rtems_event_transient_send(
rtems_id id
)
{
return rtems_event_system_send( id, RTEMS_EVENT_SYSTEM_TRANSIENT );
40005ce4: 40 00 04 92 call 40006f2c <rtems_event_system_send>
<== NOT EXECUTED
40005ce8: 13 20 00 00 sethi %hi(0x80000000), %o1
<== NOT EXECUTED
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
40005cec: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005cf0: 32 80 00 04 bne,a 40005d00 <rtems_filesystem_do_unmount+0x68>
<== NOT EXECUTED
40005cf4: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
<== NOT EXECUTED
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
40005cf8: 7f ff fa 9e call 40004770 <free>
<== NOT EXECUTED
40005cfc: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_fatal_error_occurred(0xdeadbeef);
40005d00: 40 00 06 b8 call 400077e0 <rtems_fatal_error_occurred>
<== NOT EXECUTED
40005d04: 90 12 22 ef or %o0, 0x2ef, %o0
<== NOT EXECUTED
40005d08: 01 00 00 00 nop
<== NOT EXECUTED
400054f0 <rtems_filesystem_eval_path_check_access>:
int eval_flags,
mode_t node_mode,
uid_t node_uid,
gid_t node_gid
)
{
400054f0: 9d e3 bf a0 save %sp, -96, %sp
bool access_ok = rtems_filesystem_check_access(
400054f4: 96 10 00 1c mov %i4, %o3
400054f8: 94 10 00 1b mov %i3, %o2
400054fc: 92 10 00 1a mov %i2, %o1
40005500: 7f ff ff cd call 40005434 <rtems_filesystem_check_access>
40005504: 90 10 00 19 mov %i1, %o0
node_mode,
node_uid,
node_gid
);
if (!access_ok) {
40005508: ba 92 20 00 orcc %o0, 0, %i5
4000550c: 12 80 00 04 bne 4000551c <rtems_filesystem_eval_path_check_access+0x2c>
<== ALWAYS TAKEN
40005510: 92 10 20 0d mov 0xd, %o1
rtems_filesystem_eval_path_error(ctx, EACCES);
40005514: 40 00 00 98 call 40005774 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005518: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
return access_ok;
}
4000551c: 81 c7 e0 08 ret
40005520: 91 e8 00 1d restore %g0, %i5, %o0
40005894 <rtems_filesystem_eval_path_continue>:
{
40005894: 9d e3 bf a0 save %sp, -96, %sp
while (ctx->pathlen > 0) {
40005898: c2 06 20 04 ld [ %i0 + 4 ], %g1
4000589c: 80 a0 60 00 cmp %g1, 0
400058a0: 22 80 00 0c be,a 400058d0 <rtems_filesystem_eval_path_continue+0x3c>
<== NEVER TAKEN
400058a4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
<== NOT EXECUTED
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
400058a8: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
400058ac: c2 00 60 0c ld [ %g1 + 0xc ], %g1
400058b0: c2 00 60 08 ld [ %g1 + 8 ], %g1
400058b4: 9f c0 40 00 call %g1
400058b8: 90 10 00 18 mov %i0, %o0
while (ctx->pathlen > 0) {
400058bc: c2 06 20 04 ld [ %i0 + 4 ], %g1
400058c0: 80 a0 60 00 cmp %g1, 0
400058c4: 32 bf ff fa bne,a 400058ac <rtems_filesystem_eval_path_continue+0x18>
<== NEVER TAKEN
400058c8: c2 06 20 2c ld [ %i0 + 0x2c ], %g1
<== NOT EXECUTED
if (rtems_filesystem_eval_path_has_token(ctx)) {
400058cc: c2 06 20 0c ld [ %i0 + 0xc ], %g1
400058d0: 80 a0 60 00 cmp %g1, 0
400058d4: 02 80 00 07 be 400058f0 <rtems_filesystem_eval_path_continue+0x5c>
400058d8: f2 06 20 10 ld [ %i0 + 0x10 ], %i1
if (make) {
400058dc: 80 8e 60 20 btst 0x20, %i1
400058e0: 02 80 00 08 be 40005900 <rtems_filesystem_eval_path_continue+0x6c>
<== NEVER TAKEN
400058e4: b2 10 20 02 mov 2, %i1
check_access(ctx, ctx->flags);
400058e8: 7f ff ff b9 call 400057cc <check_access>
400058ec: 81 e8 00 00 restore
if (!exclusive) {
400058f0: 80 8e 60 40 btst 0x40, %i1
400058f4: 02 bf ff fd be 400058e8 <rtems_filesystem_eval_path_continue+0x54>
<== ALWAYS TAKEN
400058f8: 01 00 00 00 nop
rtems_filesystem_eval_path_error(ctx, EEXIST);
400058fc: b2 10 20 11 mov 0x11, %i1 ! 11 <_TLS_Alignment+0x10>
<== NOT EXECUTED
40005900: 7f ff ff 9d call 40005774 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005904: 81 e8 00 00 restore
<== NOT EXECUTED
40006110 <rtems_filesystem_eval_path_eat_delimiter>:
void rtems_filesystem_eval_path_eat_delimiter(
rtems_filesystem_eval_path_context_t *ctx
)
{
const char *current = ctx->path;
40006110: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
const char *end = current + ctx->pathlen;
40006114: c4 02 20 04 ld [ %o0 + 4 ], %g2
<== NOT EXECUTED
40006118: 86 00 40 02 add %g1, %g2, %g3
<== NOT EXECUTED
while (current != end && rtems_filesystem_is_delimiter(*current)) {
4000611c: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
40006120: 22 80 00 17 be,a 4000617c <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NOT EXECUTED
40006124: 84 10 20 00 clr %g2
<== NOT EXECUTED
return c == '/' || c == '\\';
40006128: c8 48 40 00 ldsb [ %g1 ], %g4
<== NOT EXECUTED
4000612c: 80 a1 20 2f cmp %g4, 0x2f
<== NOT EXECUTED
40006130: 02 80 00 04 be 40006140 <rtems_filesystem_eval_path_eat_delimiter+0x30>
<== NOT EXECUTED
40006134: 80 a1 20 5c cmp %g4, 0x5c
<== NOT EXECUTED
40006138: 32 80 00 11 bne,a 4000617c <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NOT EXECUTED
4000613c: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
++current;
40006140: 82 00 60 01 inc %g1
<== NOT EXECUTED
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006144: 80 a0 c0 01 cmp %g3, %g1
<== NOT EXECUTED
40006148: 02 80 00 0d be 4000617c <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NOT EXECUTED
4000614c: 84 10 20 00 clr %g2
<== NOT EXECUTED
40006150: c4 48 40 00 ldsb [ %g1 ], %g2
<== NOT EXECUTED
40006154: 80 a0 a0 2f cmp %g2, 0x2f
<== NOT EXECUTED
40006158: 02 bf ff fa be 40006140 <rtems_filesystem_eval_path_eat_delimiter+0x30>
<== NOT EXECUTED
4000615c: 80 a0 a0 5c cmp %g2, 0x5c
<== NOT EXECUTED
40006160: 22 bf ff f9 be,a 40006144 <rtems_filesystem_eval_path_eat_delimiter+0x34>
<== NOT EXECUTED
40006164: 82 00 60 01 inc %g1
<== NOT EXECUTED
40006168: 84 20 c0 01 sub %g3, %g1, %g2
<== NOT EXECUTED
++current;
4000616c: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
40006170: c4 22 20 04 st %g2, [ %o0 + 4 ]
<== NOT EXECUTED
}
40006174: 81 c3 e0 08 retl
<== NOT EXECUTED
40006178: c6 22 00 00 st %g3, [ %o0 ]
<== NOT EXECUTED
ctx->path = current;
4000617c: c6 22 00 00 st %g3, [ %o0 ]
<== NOT EXECUTED
}
40006180: 81 c3 e0 08 retl
<== NOT EXECUTED
40006184: c4 22 20 04 st %g2, [ %o0 + 4 ]
<== NOT EXECUTED
40005774 <rtems_filesystem_eval_path_error>:
{
40005774: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
ctx->path = NULL;
40005778: c0 26 00 00 clr [ %i0 ]
<== NOT EXECUTED
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
4000577c: 03 10 00 43 sethi %hi(0x40010c00), %g1
<== NOT EXECUTED
ctx->pathlen = 0;
40005780: c0 26 20 04 clr [ %i0 + 4 ]
<== NOT EXECUTED
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
40005784: 82 10 61 20 or %g1, 0x120, %g1
<== NOT EXECUTED
ctx->token = NULL;
40005788: c0 26 20 08 clr [ %i0 + 8 ]
<== NOT EXECUTED
ctx->tokenlen = 0;
4000578c: c0 26 20 0c clr [ %i0 + 0xc ]
<== NOT EXECUTED
if (!rtems_filesystem_location_is_null(&ctx->currentloc)) {
40005790: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
<== NOT EXECUTED
40005794: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
40005798: 02 80 00 0b be 400057c4 <rtems_filesystem_eval_path_error+0x50>
<== NOT EXECUTED
4000579c: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
if (eno != 0) {
400057a0: 12 80 00 04 bne 400057b0 <rtems_filesystem_eval_path_error+0x3c>
<== NOT EXECUTED
400057a4: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_detach(&ctx->currentloc);
400057a8: 40 00 01 23 call 40005c34 <rtems_filesystem_location_detach>
<== NOT EXECUTED
400057ac: 91 ee 20 18 restore %i0, 0x18, %o0
<== NOT EXECUTED
errno = eno;
400057b0: 40 00 26 93 call 4000f1fc <__errno>
<== NOT EXECUTED
400057b4: b0 06 20 18 add %i0, 0x18, %i0
<== NOT EXECUTED
400057b8: f2 22 00 00 st %i1, [ %o0 ]
<== NOT EXECUTED
rtems_filesystem_location_detach(&ctx->currentloc);
400057bc: 40 00 01 1e call 40005c34 <rtems_filesystem_location_detach>
<== NOT EXECUTED
400057c0: 81 e8 00 00 restore
<== NOT EXECUTED
}
400057c4: 81 c7 e0 08 ret
<== NOT EXECUTED
400057c8: 81 e8 00 00 restore
<== NOT EXECUTED
40005524 <rtems_filesystem_eval_path_generic>:
void rtems_filesystem_eval_path_generic(
rtems_filesystem_eval_path_context_t *ctx,
void *arg,
const rtems_filesystem_eval_path_generic_config *config
)
{
40005524: 9d e3 bf a0 save %sp, -96, %sp
} else {
/* This is the root file system */
status = (*config->eval_token)(ctx, arg, ".", 1);
}
} else {
status = (*config->eval_token)(ctx, arg, "..", 2);
40005528: 21 10 00 43 sethi %hi(0x40010c00), %l0
{
4000552c: ba 10 00 18 mov %i0, %i5
return &ctx->currentloc;
40005530: a2 06 20 18 add %i0, 0x18, %l1
status = (*config->eval_token)(ctx, arg, "..", 2);
40005534: a0 14 20 d0 or %l0, 0xd0, %l0
status = (*config->eval_token)(ctx, arg, ".", 1);
40005538: 31 10 00 43 sethi %hi(0x40010c00), %i0
4000553c: b0 16 20 c8 or %i0, 0xc8, %i0 ! 40010cc8 <rtems_filesystem_default_pathconf+0x30>
rtems_filesystem_eval_path_next_token(ctx);
40005540: 40 00 03 12 call 40006188 <rtems_filesystem_eval_path_next_token>
40005544: 90 10 00 1d mov %i5, %o0
*tokenlen = ctx->tokenlen;
40005548: f8 07 60 0c ld [ %i5 + 0xc ], %i4
if (tokenlen > 0) {
4000554c: 80 a7 20 00 cmp %i4, 0
40005550: 02 80 00 19 be 400055b4 <rtems_filesystem_eval_path_generic+0x90>
<== NEVER TAKEN
40005554: f6 07 60 08 ld [ %i5 + 8 ], %i3
if ((*config->is_directory)(ctx, arg)) {
40005558: c2 06 80 00 ld [ %i2 ], %g1
4000555c: 92 10 00 19 mov %i1, %o1
40005560: 9f c0 40 00 call %g1
40005564: 90 10 00 1d mov %i5, %o0
40005568: 80 a2 20 00 cmp %o0, 0
4000556c: 02 80 00 60 be 400056ec <rtems_filesystem_eval_path_generic+0x1c8>
<== NEVER TAKEN
40005570: 80 a7 20 01 cmp %i4, 1
return tokenlen == 1 && token [0] == '.';
40005574: 02 80 00 12 be 400055bc <rtems_filesystem_eval_path_generic+0x98>
<== NEVER TAKEN
40005578: 80 a7 20 02 cmp %i4, 2
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
4000557c: 22 80 00 33 be,a 40005648 <rtems_filesystem_eval_path_generic+0x124>
<== NEVER TAKEN
40005580: c2 4e c0 00 ldsb [ %i3 ], %g1
<== NOT EXECUTED
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
40005584: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40005588: 96 10 00 1c mov %i4, %o3
4000558c: 94 10 00 1b mov %i3, %o2
40005590: 92 10 00 19 mov %i1, %o1
40005594: 9f c0 40 00 call %g1
40005598: 90 10 00 1d mov %i5, %o0
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
4000559c: 80 a2 20 02 cmp %o0, 2
400055a0: 22 80 00 19 be,a 40005604 <rtems_filesystem_eval_path_generic+0xe0>
400055a4: c2 07 60 04 ld [ %i5 + 4 ], %g1
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
400055a8: 80 a2 20 00 cmp %o0, 0
400055ac: 02 bf ff e5 be 40005540 <rtems_filesystem_eval_path_generic+0x1c>
400055b0: 01 00 00 00 nop
400055b4: 81 c7 e0 08 ret
400055b8: 81 e8 00 00 restore
return tokenlen == 1 && token [0] == '.';
400055bc: c2 4e c0 00 ldsb [ %i3 ], %g1
<== NOT EXECUTED
400055c0: 80 a0 60 2e cmp %g1, 0x2e
<== NOT EXECUTED
400055c4: 32 bf ff f1 bne,a 40005588 <rtems_filesystem_eval_path_generic+0x64>
<== NOT EXECUTED
400055c8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
if (rtems_filesystem_eval_path_has_path(ctx)) {
400055cc: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
400055d0: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400055d4: 22 80 00 40 be,a 400056d4 <rtems_filesystem_eval_path_generic+0x1b0>
<== NOT EXECUTED
400055d8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
status = (*config->eval_token)(ctx, arg, ".", 1);
400055dc: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
400055e0: 96 10 20 01 mov 1, %o3
<== NOT EXECUTED
400055e4: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
400055e8: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400055ec: 9f c0 40 00 call %g1
<== NOT EXECUTED
400055f0: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
400055f4: 80 a2 20 02 cmp %o0, 2
<== NOT EXECUTED
400055f8: 12 bf ff ed bne 400055ac <rtems_filesystem_eval_path_generic+0x88>
<== NOT EXECUTED
400055fc: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
if (rtems_filesystem_eval_path_has_path(ctx)) {
40005600: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
40005604: 80 a0 60 00 cmp %g1, 0
40005608: 12 80 00 04 bne 40005618 <rtems_filesystem_eval_path_generic+0xf4>
<== NEVER TAKEN
4000560c: 01 00 00 00 nop
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
}
40005610: 81 c7 e0 08 ret
40005614: 81 e8 00 00 restore
rtems_filesystem_eval_path_eat_delimiter(ctx);
40005618: 40 00 02 be call 40006110 <rtems_filesystem_eval_path_eat_delimiter>
<== NOT EXECUTED
4000561c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
40005620: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
if (
40005624: 80 88 60 80 btst 0x80, %g1
<== NOT EXECUTED
40005628: 02 80 00 06 be 40005640 <rtems_filesystem_eval_path_generic+0x11c>
<== NOT EXECUTED
4000562c: b2 10 20 02 mov 2, %i1
<== NOT EXECUTED
|| rtems_filesystem_eval_path_has_path(ctx)
40005630: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
40005634: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40005638: 02 bf ff f6 be 40005610 <rtems_filesystem_eval_path_generic+0xec>
<== NOT EXECUTED
4000563c: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ENOENT);
40005640: 40 00 00 4d call 40005774 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005644: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
40005648: 80 a0 60 2e cmp %g1, 0x2e
<== NOT EXECUTED
4000564c: 32 bf ff cf bne,a 40005588 <rtems_filesystem_eval_path_generic+0x64>
<== NOT EXECUTED
40005650: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
40005654: c2 4e e0 01 ldsb [ %i3 + 1 ], %g1
<== NOT EXECUTED
40005658: 80 a0 60 2e cmp %g1, 0x2e
<== NOT EXECUTED
4000565c: 32 bf ff cb bne,a 40005588 <rtems_filesystem_eval_path_generic+0x64>
<== NOT EXECUTED
40005660: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40005664: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
40005668: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
<== NOT EXECUTED
4000566c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
40005670: c6 02 60 14 ld [ %o1 + 0x14 ], %g3
<== NOT EXECUTED
40005674: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
40005678: 12 80 00 0a bne 400056a0 <rtems_filesystem_eval_path_generic+0x17c>
<== NOT EXECUTED
4000567c: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
<== NOT EXECUTED
40005680: 9f c0 80 00 call %g2
<== NOT EXECUTED
40005684: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
40005688: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000568c: 32 bf ff d5 bne,a 400055e0 <rtems_filesystem_eval_path_generic+0xbc>
<== NOT EXECUTED
40005690: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
40005694: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
40005698: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
4000569c: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
<== NOT EXECUTED
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
400056a0: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
<== NOT EXECUTED
400056a4: 9f c0 80 00 call %g2
<== NOT EXECUTED
400056a8: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
} else if (is_fs_root(currentloc)) {
400056ac: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400056b0: 12 80 00 12 bne 400056f8 <rtems_filesystem_eval_path_generic+0x1d4>
<== NOT EXECUTED
400056b4: 96 10 20 02 mov 2, %o3
<== NOT EXECUTED
status = (*config->eval_token)(ctx, arg, "..", 2);
400056b8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
400056bc: 94 10 00 10 mov %l0, %o2
<== NOT EXECUTED
400056c0: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400056c4: 9f c0 40 00 call %g1
<== NOT EXECUTED
400056c8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
400056cc: 10 bf ff b5 b 400055a0 <rtems_filesystem_eval_path_generic+0x7c>
<== NOT EXECUTED
400056d0: 80 a2 20 02 cmp %o0, 2
<== NOT EXECUTED
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
400056d4: 80 88 61 00 btst 0x100, %g1
<== NOT EXECUTED
400056d8: 22 bf ff c2 be,a 400055e0 <rtems_filesystem_eval_path_generic+0xbc>
<== NOT EXECUTED
400056dc: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, EINVAL);
400056e0: b2 10 20 16 mov 0x16, %i1
<== NOT EXECUTED
400056e4: 40 00 00 24 call 40005774 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
400056e8: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
400056ec: b2 10 20 14 mov 0x14, %i1
<== NOT EXECUTED
400056f0: 40 00 00 21 call 40005774 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
400056f4: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
if (currentloc->mt_entry->mt_point_node != NULL) {
400056f8: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
400056fc: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
<== NOT EXECUTED
40005700: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40005704: 22 bf ff b7 be,a 400055e0 <rtems_filesystem_eval_path_generic+0xbc>
<== NOT EXECUTED
40005708: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
size_t tokenlen = ctx->tokenlen;
4000570c: c8 07 60 0c ld [ %i5 + 0xc ], %g4
<== NOT EXECUTED
ctx->path -= tokenlen;
40005710: c6 07 40 00 ld [ %i5 ], %g3
<== NOT EXECUTED
ctx->pathlen += tokenlen;
40005714: c4 07 60 04 ld [ %i5 + 4 ], %g2
<== NOT EXECUTED
ctx->path -= tokenlen;
40005718: 86 20 c0 04 sub %g3, %g4, %g3
<== NOT EXECUTED
ctx->pathlen += tokenlen;
4000571c: 84 00 80 04 add %g2, %g4, %g2
<== NOT EXECUTED
ctx->path -= tokenlen;
40005720: c6 27 40 00 st %g3, [ %i5 ]
<== NOT EXECUTED
rtems_filesystem_eval_path_restart(
40005724: b2 00 60 20 add %g1, 0x20, %i1
<== NOT EXECUTED
ctx->pathlen += tokenlen;
40005728: c4 27 60 04 st %g2, [ %i5 + 4 ]
<== NOT EXECUTED
ctx->tokenlen = 0;
4000572c: c0 27 60 0c clr [ %i5 + 0xc ]
<== NOT EXECUTED
40005730: 40 00 00 e7 call 40005acc <rtems_filesystem_eval_path_restart>
<== NOT EXECUTED
40005734: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
40006188 <rtems_filesystem_eval_path_next_token>:
const char *current = ctx->path;
40006188: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
4000618c: c6 02 20 04 ld [ %o0 + 4 ], %g3
40006190: 86 00 40 03 add %g1, %g3, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006194: 80 a0 40 03 cmp %g1, %g3
40006198: 32 80 00 09 bne,a 400061bc <rtems_filesystem_eval_path_next_token+0x34>
<== ALWAYS TAKEN
4000619c: c4 48 40 00 ldsb [ %g1 ], %g2
400061a0: 10 80 00 20 b 40006220 <rtems_filesystem_eval_path_next_token+0x98>
<== NOT EXECUTED
400061a4: 9a 10 20 00 clr %o5
<== NOT EXECUTED
++current;
400061a8: 82 00 60 01 inc %g1
while (current != end && rtems_filesystem_is_delimiter(*current)) {
400061ac: 80 a0 c0 01 cmp %g3, %g1
400061b0: 22 80 00 22 be,a 40006238 <rtems_filesystem_eval_path_next_token+0xb0>
<== NEVER TAKEN
400061b4: 82 10 00 03 mov %g3, %g1
<== NOT EXECUTED
400061b8: c4 48 40 00 ldsb [ %g1 ], %g2
400061bc: 80 a0 a0 2f cmp %g2, 0x2f
400061c0: 02 bf ff fa be 400061a8 <rtems_filesystem_eval_path_next_token+0x20>
400061c4: 80 a0 a0 5c cmp %g2, 0x5c
400061c8: 22 bf ff f9 be,a 400061ac <rtems_filesystem_eval_path_next_token+0x24>
<== NEVER TAKEN
400061cc: 82 00 60 01 inc %g1
<== NOT EXECUTED
ctx->path = current;
400061d0: c2 22 00 00 st %g1, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
400061d4: 9a 20 c0 01 sub %g3, %g1, %o5
400061d8: da 22 20 04 st %o5, [ %o0 + 4 ]
400061dc: c4 48 40 00 ldsb [ %g1 ], %g2
{
const char *begin = ctx->path;
const char *end = begin + ctx->pathlen;
const char *current = begin;
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
400061e0: 80 a0 a0 5c cmp %g2, 0x5c
400061e4: 02 80 00 1f be 40006260 <rtems_filesystem_eval_path_next_token+0xd8>
<== NEVER TAKEN
400061e8: 80 a0 a0 2f cmp %g2, 0x2f
400061ec: 02 80 00 1e be 40006264 <rtems_filesystem_eval_path_next_token+0xdc>
<== NEVER TAKEN
400061f0: 88 10 00 0d mov %o5, %g4
400061f4: 10 80 00 07 b 40006210 <rtems_filesystem_eval_path_next_token+0x88>
400061f8: 84 10 00 01 mov %g1, %g2
400061fc: 80 a1 20 2f cmp %g4, 0x2f
40006200: 02 80 00 10 be 40006240 <rtems_filesystem_eval_path_next_token+0xb8>
40006204: 80 a1 20 5c cmp %g4, 0x5c
40006208: 02 80 00 0f be 40006244 <rtems_filesystem_eval_path_next_token+0xbc>
<== NEVER TAKEN
4000620c: 88 20 c0 02 sub %g3, %g2, %g4
++current;
40006210: 84 00 a0 01 inc %g2
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
40006214: 80 a0 80 03 cmp %g2, %g3
40006218: 32 bf ff f9 bne,a 400061fc <rtems_filesystem_eval_path_next_token+0x74>
4000621c: c8 48 80 00 ldsb [ %g2 ], %g4
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006220: 88 10 20 00 clr %g4
}
ctx->path = current;
40006224: c6 22 00 00 st %g3, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
40006228: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->token = begin;
4000622c: c2 22 20 08 st %g1, [ %o0 + 8 ]
rtems_filesystem_eval_path_context_t *ctx
)
{
rtems_filesystem_eval_path_eat_delimiter(ctx);
next_token(ctx);
}
40006230: 81 c3 e0 08 retl
40006234: da 22 20 0c st %o5, [ %o0 + 0xc ]
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40006238: 10 bf ff fa b 40006220 <rtems_filesystem_eval_path_next_token+0x98>
<== NOT EXECUTED
4000623c: 9a 10 20 00 clr %o5
<== NOT EXECUTED
40006240: 88 20 c0 02 sub %g3, %g2, %g4
40006244: 9a 20 80 01 sub %g2, %g1, %o5
++current;
40006248: 86 10 00 02 mov %g2, %g3
ctx->pathlen = (size_t) (end - current);
4000624c: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->path = current;
40006250: c6 22 00 00 st %g3, [ %o0 ]
ctx->token = begin;
40006254: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
40006258: 81 c3 e0 08 retl
4000625c: da 22 20 0c st %o5, [ %o0 + 0xc ]
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
40006260: 88 10 00 0d mov %o5, %g4
<== NOT EXECUTED
40006264: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
40006268: 10 bf ff ef b 40006224 <rtems_filesystem_eval_path_next_token+0x9c>
<== NOT EXECUTED
4000626c: 9a 10 20 00 clr %o5
<== NOT EXECUTED
40005b30 <rtems_filesystem_eval_path_recursive>:
{
40005b30: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if (pathlen > 0) {
40005b34: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40005b38: 02 80 00 22 be 40005bc0 <rtems_filesystem_eval_path_recursive+0x90>
<== NOT EXECUTED
40005b3c: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
40005b40: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
40005b44: 80 a0 60 1f cmp %g1, 0x1f
<== NOT EXECUTED
40005b48: 14 80 00 20 bg 40005bc8 <rtems_filesystem_eval_path_recursive+0x98>
<== NOT EXECUTED
40005b4c: 01 00 00 00 nop
<== NOT EXECUTED
return c == '/' || c == '\\';
40005b50: c4 4e 40 00 ldsb [ %i1 ], %g2
<== NOT EXECUTED
const char *saved_path = ctx->path;
40005b54: f6 06 00 00 ld [ %i0 ], %i3
<== NOT EXECUTED
if (rtems_filesystem_is_delimiter(path [0])) {
40005b58: 80 a0 a0 2f cmp %g2, 0x2f
<== NOT EXECUTED
40005b5c: 02 80 00 1d be 40005bd0 <rtems_filesystem_eval_path_recursive+0xa0>
<== NOT EXECUTED
40005b60: f8 06 20 04 ld [ %i0 + 4 ], %i4
<== NOT EXECUTED
40005b64: 80 a0 a0 5c cmp %g2, 0x5c
<== NOT EXECUTED
40005b68: 02 80 00 1b be 40005bd4 <rtems_filesystem_eval_path_recursive+0xa4>
<== NOT EXECUTED
40005b6c: 92 07 60 30 add %i5, 0x30, %o1
<== NOT EXECUTED
++ctx->recursionlevel;
40005b70: 82 00 60 01 inc %g1
<== NOT EXECUTED
ctx->path = path;
40005b74: f2 27 40 00 st %i1, [ %i5 ]
<== NOT EXECUTED
ctx->pathlen = pathlen;
40005b78: f4 27 60 04 st %i2, [ %i5 + 4 ]
<== NOT EXECUTED
++ctx->recursionlevel;
40005b7c: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
<== NOT EXECUTED
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
40005b80: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
40005b84: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
40005b88: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
40005b8c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005b90: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
while (ctx->pathlen > 0) {
40005b94: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
40005b98: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40005b9c: 32 bf ff fa bne,a 40005b84 <rtems_filesystem_eval_path_recursive+0x54>
<== NOT EXECUTED
40005ba0: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
--ctx->recursionlevel;
40005ba4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
40005ba8: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
ctx->path = saved_path;
40005bac: f6 27 40 00 st %i3, [ %i5 ]
<== NOT EXECUTED
--ctx->recursionlevel;
40005bb0: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
<== NOT EXECUTED
ctx->pathlen = saved_pathlen;
40005bb4: f8 27 60 04 st %i4, [ %i5 + 4 ]
<== NOT EXECUTED
}
40005bb8: 81 c7 e0 08 ret
<== NOT EXECUTED
40005bbc: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ENOENT);
40005bc0: 7f ff fe ed call 40005774 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005bc4: 93 e8 20 02 restore %g0, 2, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ELOOP);
40005bc8: 7f ff fe eb call 40005774 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40005bcc: 93 e8 20 5c restore %g0, 0x5c, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
40005bd0: 92 07 60 30 add %i5, 0x30, %o1
<== NOT EXECUTED
40005bd4: 7f ff ff be call 40005acc <rtems_filesystem_eval_path_restart>
<== NOT EXECUTED
40005bd8: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40005bdc: 10 bf ff e5 b 40005b70 <rtems_filesystem_eval_path_recursive+0x40>
<== NOT EXECUTED
40005be0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
40005acc <rtems_filesystem_eval_path_restart>:
void rtems_filesystem_eval_path_restart(
rtems_filesystem_eval_path_context_t *ctx,
rtems_filesystem_global_location_t **newstartloc_ptr
)
{
40005acc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
40005ad0: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
free_location(&ctx->currentloc);
40005ad4: b0 06 20 18 add %i0, 0x18, %i0
<== NOT EXECUTED
40005ad8: 7f ff ff 18 call 40005738 <free_location>
<== NOT EXECUTED
40005adc: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40005ae0: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
<== NOT EXECUTED
40005ae4: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
<== NOT EXECUTED
40005ae8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
40005aec: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
40005af0: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005af4: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_instance_unlock(&ctx->startloc->location);
rtems_filesystem_global_location_assign(
40005af8: 40 00 00 b1 call 40005dbc <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
40005afc: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40005b00: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
40005b04: 40 00 01 02 call 40005f0c <rtems_filesystem_global_location_assign>
<== NOT EXECUTED
40005b08: 90 07 60 34 add %i5, 0x34, %o0
<== NOT EXECUTED
40005b0c: c2 07 60 34 ld [ %i5 + 0x34 ], %g1
<== NOT EXECUTED
40005b10: d0 00 60 14 ld [ %g1 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
40005b14: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
40005b18: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
40005b1c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005b20: 01 00 00 00 nop
<== NOT EXECUTED
&ctx->startloc,
rtems_filesystem_global_location_obtain(newstartloc_ptr)
);
rtems_filesystem_instance_lock(&ctx->startloc->location);
rtems_filesystem_location_clone(&ctx->currentloc, &ctx->startloc->location);
40005b24: f2 07 60 34 ld [ %i5 + 0x34 ], %i1
<== NOT EXECUTED
40005b28: 40 00 21 99 call 4000e18c <rtems_filesystem_location_clone>
<== NOT EXECUTED
40005b2c: 81 e8 00 00 restore
<== NOT EXECUTED
40005908 <rtems_filesystem_eval_path_start_with_root_and_current>:
{
40005908: 9d e3 bf 98 save %sp, -104, %sp
memset(ctx, 0, sizeof(*ctx));
4000590c: 94 10 20 30 mov 0x30, %o2
40005910: 92 10 20 00 clr %o1
40005914: 40 00 26 a4 call 4000f3a4 <memset>
40005918: 90 06 20 08 add %i0, 8, %o0
ctx->path = path;
4000591c: f2 26 00 00 st %i1, [ %i0 ]
if (ctx->pathlen > 0) {
40005920: 80 a6 a0 00 cmp %i2, 0
ctx->pathlen = pathlen;
40005924: f4 26 20 04 st %i2, [ %i0 + 4 ]
if (ctx->pathlen > 0) {
40005928: 02 80 00 1d be 4000599c <rtems_filesystem_eval_path_start_with_root_and_current+0x94>
<== NEVER TAKEN
4000592c: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
char c = ctx->path [0];
40005930: f6 0e 40 00 ldub [ %i1 ], %i3
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
40005934: 40 00 01 22 call 40005dbc <rtems_filesystem_global_location_obtain>
40005938: 90 10 00 1c mov %i4, %o0
return c == '/' || c == '\\';
4000593c: 83 2e e0 18 sll %i3, 0x18, %g1
40005940: 83 38 60 18 sra %g1, 0x18, %g1
if (rtems_filesystem_is_delimiter(c)) {
40005944: 80 a0 60 2f cmp %g1, 0x2f
40005948: 02 80 00 2f be 40005a04 <rtems_filesystem_eval_path_start_with_root_and_current+0xfc>
<== ALWAYS TAKEN
4000594c: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
40005950: 80 a0 60 5c cmp %g1, 0x5c
<== NOT EXECUTED
40005954: 22 80 00 2d be,a 40005a08 <rtems_filesystem_eval_path_start_with_root_and_current+0x100>
<== NOT EXECUTED
40005958: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
ctx->startloc = rtems_filesystem_global_location_obtain(
4000595c: 40 00 01 18 call 40005dbc <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
40005960: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40005964: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
<== NOT EXECUTED
40005968: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
4000596c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
40005970: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
40005974: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005978: ba 06 20 18 add %i0, 0x18, %i5
<== NOT EXECUTED
rtems_filesystem_location_clone(
4000597c: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
<== NOT EXECUTED
40005980: 40 00 22 03 call 4000e18c <rtems_filesystem_location_clone>
<== NOT EXECUTED
40005984: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
rtems_filesystem_eval_path_continue(ctx);
40005988: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000598c: 7f ff ff c2 call 40005894 <rtems_filesystem_eval_path_continue>
<== NOT EXECUTED
40005990: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
40005994: 81 c7 e0 08 ret
<== NOT EXECUTED
40005998: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_global_location_t *global_loc = NULL;
4000599c: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
400059a0: 40 00 01 07 call 40005dbc <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
400059a4: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
ctx->rootloc = rtems_filesystem_global_location_obtain_null();
400059a8: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
<== NOT EXECUTED
400059ac: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
400059b0: 40 00 01 03 call 40005dbc <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
400059b4: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
ctx->startloc = rtems_filesystem_global_location_obtain_null();
400059b8: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
<== NOT EXECUTED
errno = ENOENT;
400059bc: 40 00 26 10 call 4000f1fc <__errno>
<== NOT EXECUTED
400059c0: ba 06 20 18 add %i0, 0x18, %i5
<== NOT EXECUTED
400059c4: 82 10 20 02 mov 2, %g1
<== NOT EXECUTED
400059c8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400059cc: d0 06 20 34 ld [ %i0 + 0x34 ], %o0
<== NOT EXECUTED
400059d0: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
400059d4: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
400059d8: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
400059dc: 9f c0 40 00 call %g1
<== NOT EXECUTED
400059e0: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_clone(
400059e4: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
<== NOT EXECUTED
400059e8: 40 00 21 e9 call 4000e18c <rtems_filesystem_location_clone>
<== NOT EXECUTED
400059ec: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
rtems_filesystem_eval_path_continue(ctx);
400059f0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400059f4: 7f ff ff a8 call 40005894 <rtems_filesystem_eval_path_continue>
<== NOT EXECUTED
400059f8: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
400059fc: 81 c7 e0 08 ret
<== NOT EXECUTED
40005a00: 81 e8 00 00 restore
<== NOT EXECUTED
++ctx->path;
40005a04: c4 06 00 00 ld [ %i0 ], %g2
--ctx->pathlen;
40005a08: c2 06 20 04 ld [ %i0 + 4 ], %g1
++ctx->path;
40005a0c: 84 00 a0 01 inc %g2
--ctx->pathlen;
40005a10: 82 00 7f ff add %g1, -1, %g1
++ctx->path;
40005a14: c4 26 00 00 st %g2, [ %i0 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
40005a18: 90 06 20 30 add %i0, 0x30, %o0
--ctx->pathlen;
40005a1c: c2 26 20 04 st %g1, [ %i0 + 4 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
40005a20: 40 00 00 e7 call 40005dbc <rtems_filesystem_global_location_obtain>
40005a24: ba 06 20 18 add %i0, 0x18, %i5
40005a28: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
40005a2c: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
40005a30: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40005a34: c2 00 40 00 ld [ %g1 ], %g1
40005a38: 9f c0 40 00 call %g1
40005a3c: 01 00 00 00 nop
rtems_filesystem_location_clone(
40005a40: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40005a44: 40 00 21 d2 call 4000e18c <rtems_filesystem_location_clone>
40005a48: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_continue(ctx);
40005a4c: 90 10 00 18 mov %i0, %o0
40005a50: 7f ff ff 91 call 40005894 <rtems_filesystem_eval_path_continue>
40005a54: b0 10 00 1d mov %i5, %i0
}
40005a58: 81 c7 e0 08 ret
40005a5c: 81 e8 00 00 restore
4000e4f0 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
4000e4f0: 9d e3 bf 98 save %sp, -104, %sp
4000e4f4: 82 10 00 18 mov %i0, %g1
find_arg fa = {
4000e4f8: c0 27 bf fc clr [ %fp + -4 ]
4000e4fc: b0 10 20 00 clr %i0
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
4000e500: 80 a0 60 00 cmp %g1, 0
4000e504: 02 80 00 07 be 4000e520 <rtems_filesystem_get_mount_handler+0x30>
<== NEVER TAKEN
4000e508: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_filesystem_iterate( find_handler, &fa );
4000e50c: 92 07 bf f8 add %fp, -8, %o1
4000e510: 11 10 00 39 sethi %hi(0x4000e400), %o0
4000e514: 7f ff ff cb call 4000e440 <rtems_filesystem_iterate>
4000e518: 90 12 20 0c or %o0, 0xc, %o0 ! 4000e40c <find_handler>
4000e51c: f0 07 bf fc ld [ %fp + -4 ], %i0
}
return fa.mount_h;
}
4000e520: 81 c7 e0 08 ret
4000e524: 81 e8 00 00 restore
40005f0c <rtems_filesystem_global_location_assign>:
{
40005f0c: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005f10: 91 d0 20 09 ta 9
<== NOT EXECUTED
lhs_global_loc = *lhs_global_loc_ptr;
40005f14: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
*lhs_global_loc_ptr = rhs_global_loc;
40005f18: d2 20 80 00 st %o1, [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005f1c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005f20: 01 00 00 00 nop
rtems_filesystem_global_location_release(lhs_global_loc, true);
40005f24: 92 10 20 01 mov 1, %o1 ! 1 <_TLS_Alignment>
40005f28: 82 13 c0 00 mov %o7, %g1
40005f2c: 7f ff ff de call 40005ea4 <rtems_filesystem_global_location_release>
40005f30: 9e 10 40 00 mov %g1, %o7
40005dbc <rtems_filesystem_global_location_obtain>:
{
40005dbc: 9d e3 bf 98 save %sp, -104, %sp
if (deferred_released_global_locations != NULL) {
40005dc0: 3b 10 00 4d sethi %hi(0x40013400), %i5
40005dc4: c2 07 63 74 ld [ %i5 + 0x374 ], %g1 ! 40013774 <deferred_released_global_locations>
40005dc8: 80 a0 60 00 cmp %g1, 0
40005dcc: 02 80 00 1e be 40005e44 <rtems_filesystem_global_location_obtain+0x88>
40005dd0: 01 00 00 00 nop
40005dd4: ba 17 63 74 or %i5, 0x374, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005dd8: 91 d0 20 09 ta 9
<== NOT EXECUTED
current = deferred_released_global_locations;
40005ddc: d0 07 40 00 ld [ %i5 ], %o0
if (current != NULL) {
40005de0: 80 a2 20 00 cmp %o0, 0
40005de4: 02 80 00 07 be 40005e00 <rtems_filesystem_global_location_obtain+0x44>
<== NEVER TAKEN
40005de8: 92 10 20 00 clr %o1
<== NOT EXECUTED
deferred_released_global_locations = current->deferred_released_next;
40005dec: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
<== NOT EXECUTED
count = current->deferred_released_count;
40005df0: d2 02 20 20 ld [ %o0 + 0x20 ], %o1
<== NOT EXECUTED
deferred_released_global_locations = current->deferred_released_next;
40005df4: c4 27 40 00 st %g2, [ %i5 ]
<== NOT EXECUTED
current->deferred_released_next = NULL;
40005df8: c0 22 20 1c clr [ %o0 + 0x1c ]
<== NOT EXECUTED
current->deferred_released_count = 0;
40005dfc: c0 22 20 20 clr [ %o0 + 0x20 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005e00: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005e04: 01 00 00 00 nop
if (current != NULL) {
40005e08: 80 a2 20 00 cmp %o0, 0
40005e0c: 02 80 00 0e be 40005e44 <rtems_filesystem_global_location_obtain+0x88>
<== NEVER TAKEN
40005e10: 01 00 00 00 nop
release_with_count(current, count);
40005e14: 7f ff ff be call 40005d0c <release_with_count>
40005e18: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005e1c: 91 d0 20 09 ta 9
<== NOT EXECUTED
current = deferred_released_global_locations;
40005e20: d0 07 40 00 ld [ %i5 ], %o0
if (current != NULL) {
40005e24: 80 a2 20 00 cmp %o0, 0
40005e28: 12 bf ff f1 bne 40005dec <rtems_filesystem_global_location_obtain+0x30>
<== NEVER TAKEN
40005e2c: 92 10 20 00 clr %o1
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005e30: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005e34: 01 00 00 00 nop
if (current != NULL) {
40005e38: 80 a2 20 00 cmp %o0, 0
40005e3c: 12 bf ff f6 bne 40005e14 <rtems_filesystem_global_location_obtain+0x58>
<== NEVER TAKEN
40005e40: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005e44: 91 d0 20 09 ta 9
<== NOT EXECUTED
global_loc = *global_loc_ptr;
40005e48: f0 06 00 00 ld [ %i0 ], %i0
if (global_loc == NULL || !global_loc->location.mt_entry->mounted) {
40005e4c: 80 a6 20 00 cmp %i0, 0
40005e50: 02 80 00 07 be 40005e6c <rtems_filesystem_global_location_obtain+0xb0>
<== NEVER TAKEN
40005e54: 01 00 00 00 nop
40005e58: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
40005e5c: c4 08 a0 28 ldub [ %g2 + 0x28 ], %g2
40005e60: 80 a0 a0 00 cmp %g2, 0
40005e64: 32 80 00 0a bne,a 40005e8c <rtems_filesystem_global_location_obtain+0xd0>
<== ALWAYS TAKEN
40005e68: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
errno = ENXIO;
40005e6c: 40 00 24 e4 call 4000f1fc <__errno>
<== NOT EXECUTED
40005e70: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
40005e74: 84 10 20 06 mov 6, %g2
<== NOT EXECUTED
40005e78: c4 22 00 00 st %g2, [ %o0 ]
<== NOT EXECUTED
global_loc = &rtems_filesystem_global_location_null;
40005e7c: 31 10 00 49 sethi %hi(0x40012400), %i0
<== NOT EXECUTED
40005e80: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
40005e84: b0 16 23 18 or %i0, 0x318, %i0
<== NOT EXECUTED
++global_loc->reference_count;
40005e88: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
<== NOT EXECUTED
40005e8c: 84 00 a0 01 inc %g2
<== NOT EXECUTED
40005e90: c4 26 20 18 st %g2, [ %i0 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005e94: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005e98: 01 00 00 00 nop
}
40005e9c: 81 c7 e0 08 ret
40005ea0: 81 e8 00 00 restore
40005ea4 <rtems_filesystem_global_location_release>:
if (!deferred) {
40005ea4: 80 a2 60 00 cmp %o1, 0
40005ea8: 22 80 00 16 be,a 40005f00 <rtems_filesystem_global_location_release+0x5c>
40005eac: 92 10 20 01 mov 1, %o1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005eb0: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (global_loc->deferred_released_count == 0) {
40005eb4: c6 02 20 20 ld [ %o0 + 0x20 ], %g3
40005eb8: 80 a0 e0 00 cmp %g3, 0
40005ebc: 22 80 00 08 be,a 40005edc <rtems_filesystem_global_location_release+0x38>
40005ec0: 07 10 00 4d sethi %hi(0x40013400), %g3
++global_loc->deferred_released_count;
40005ec4: 86 00 e0 01 inc %g3
<== NOT EXECUTED
40005ec8: c6 22 20 20 st %g3, [ %o0 + 0x20 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005ecc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005ed0: 01 00 00 00 nop
}
40005ed4: 81 c3 e0 08 retl
40005ed8: 01 00 00 00 nop
rtems_filesystem_global_location_t *head =
40005edc: c8 00 e3 74 ld [ %g3 + 0x374 ], %g4
<== NOT EXECUTED
global_loc->deferred_released_next = head;
40005ee0: c8 22 20 1c st %g4, [ %o0 + 0x1c ]
<== NOT EXECUTED
global_loc->deferred_released_count = 1;
40005ee4: 88 10 20 01 mov 1, %g4
<== NOT EXECUTED
deferred_released_global_locations = global_loc;
40005ee8: d0 20 e3 74 st %o0, [ %g3 + 0x374 ]
<== NOT EXECUTED
global_loc->deferred_released_count = 1;
40005eec: c8 22 20 20 st %g4, [ %o0 + 0x20 ]
<== NOT EXECUTED
40005ef0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005ef4: 01 00 00 00 nop
}
40005ef8: 81 c3 e0 08 retl
40005efc: 01 00 00 00 nop
release_with_count(global_loc, 1);
40005f00: 82 13 c0 00 mov %o7, %g1
40005f04: 7f ff ff 82 call 40005d0c <release_with_count>
40005f08: 9e 10 40 00 mov %g1, %o7
40004670 <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
40004670: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
40004674: 05 10 00 42 sethi %hi(0x40010800), %g2
40004678: 82 10 a0 d4 or %g2, 0xd4, %g1 ! 400108d4 <rtems_filesystem_root_configuration>
4000467c: d0 00 a0 d4 ld [ %g2 + 0xd4 ], %o0
40004680: d8 00 60 10 ld [ %g1 + 0x10 ], %o4
40004684: d6 00 60 0c ld [ %g1 + 0xc ], %o3
40004688: d4 00 60 08 ld [ %g1 + 8 ], %o2
4000468c: 40 00 01 a4 call 40004d1c <mount>
40004690: d2 00 60 04 ld [ %g1 + 4 ], %o1
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
40004694: 80 a2 20 00 cmp %o0, 0
40004698: 12 80 00 0a bne 400046c0 <rtems_filesystem_initialize+0x50>
<== NEVER TAKEN
4000469c: 92 10 21 ed mov 0x1ed, %o1
* Traditionally RTEMS devices are under "/dev" so install this directory.
*
* If the mkdir() fails, we can't print anything so just fatal error.
*/
rv = mkdir( "/dev", S_IRWXU | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH );
400046a0: 11 10 00 43 sethi %hi(0x40010c00), %o0
400046a4: 40 00 01 56 call 40004bfc <mkdir>
400046a8: 90 12 20 28 or %o0, 0x28, %o0 ! 40010c28 <IMFS_node_control_sym_link+0x14>
if ( rv != 0 )
400046ac: 80 a2 20 00 cmp %o0, 0
400046b0: 12 80 00 07 bne 400046cc <rtems_filesystem_initialize+0x5c>
<== NEVER TAKEN
400046b4: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
* it will be mounted onto is created. Moreover, if it is going to
* use a device, then it is REALLY unfair to attempt this
* before device drivers are initialized. So we return via a base
* filesystem image and nothing auto-mounted at this point.
*/
}
400046b8: 81 c7 e0 08 ret
400046bc: 81 e8 00 00 restore
rtems_fatal_error_occurred( 0xABCD0002 );
400046c0: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
<== NOT EXECUTED
400046c4: 40 00 0c 47 call 400077e0 <rtems_fatal_error_occurred>
<== NOT EXECUTED
400046c8: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <RAM_END+0x6b8d0002>
<== NOT EXECUTED
rtems_fatal_error_occurred( 0xABCD0003 );
400046cc: 40 00 0c 45 call 400077e0 <rtems_fatal_error_occurred>
<== NOT EXECUTED
400046d0: 90 12 20 03 or %o0, 3, %o0
<== NOT EXECUTED
400046d4: 01 00 00 00 nop
<== NOT EXECUTED
4000e440 <rtems_filesystem_iterate>:
{
4000e440: 9d e3 bf a0 save %sp, -96, %sp
while ( table_entry->type && !stop ) {
4000e444: 3b 10 00 42 sethi %hi(0x40010800), %i5
4000e448: c2 07 61 50 ld [ %i5 + 0x150 ], %g1 ! 40010950 <rtems_filesystem_table>
4000e44c: 80 a0 60 00 cmp %g1, 0
4000e450: 12 80 00 06 bne 4000e468 <rtems_filesystem_iterate+0x28>
<== ALWAYS TAKEN
4000e454: ba 17 61 50 or %i5, 0x150, %i5
4000e458: 30 80 00 0f b,a 4000e494 <rtems_filesystem_iterate+0x54>
<== NOT EXECUTED
4000e45c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e460: 32 80 00 22 bne,a 4000e4e8 <rtems_filesystem_iterate+0xa8>
<== NOT EXECUTED
4000e464: b8 0f 20 ff and %i4, 0xff, %i4
<== NOT EXECUTED
stop = (*routine)( table_entry, routine_arg );
4000e468: 90 10 00 1d mov %i5, %o0
4000e46c: 9f c6 00 00 call %i0
4000e470: 92 10 00 19 mov %i1, %o1
++table_entry;
4000e474: ba 07 60 08 add %i5, 8, %i5
while ( table_entry->type && !stop ) {
4000e478: c2 07 40 00 ld [ %i5 ], %g1
4000e47c: 80 a0 60 00 cmp %g1, 0
4000e480: 12 bf ff f7 bne 4000e45c <rtems_filesystem_iterate+0x1c>
<== NEVER TAKEN
4000e484: b8 10 00 08 mov %o0, %i4
if ( !stop ) {
4000e488: b8 8a 20 ff andcc %o0, 0xff, %i4
4000e48c: 12 80 00 17 bne 4000e4e8 <rtems_filesystem_iterate+0xa8>
<== ALWAYS TAKEN
4000e490: 01 00 00 00 nop
rtems_libio_lock();
4000e494: 7f ff d9 2b call 40004940 <rtems_libio_lock>
<== NOT EXECUTED
4000e498: 37 10 00 4a sethi %hi(0x40012800), %i3
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000e49c: fa 06 e0 f0 ld [ %i3 + 0xf0 ], %i5 ! 400128f0 <filesystem_chain>
<== NOT EXECUTED
4000e4a0: b6 16 e0 f0 or %i3, 0xf0, %i3
<== NOT EXECUTED
for (
4000e4a4: b6 06 e0 04 add %i3, 4, %i3
<== NOT EXECUTED
4000e4a8: 80 a7 40 1b cmp %i5, %i3
<== NOT EXECUTED
4000e4ac: 12 80 00 06 bne 4000e4c4 <rtems_filesystem_iterate+0x84>
<== NOT EXECUTED
4000e4b0: b8 10 20 00 clr %i4
<== NOT EXECUTED
4000e4b4: 30 80 00 0b b,a 4000e4e0 <rtems_filesystem_iterate+0xa0>
<== NOT EXECUTED
!rtems_chain_is_tail( chain, node ) && !stop;
4000e4b8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000e4bc: 12 80 00 09 bne 4000e4e0 <rtems_filesystem_iterate+0xa0>
<== NOT EXECUTED
4000e4c0: 01 00 00 00 nop
<== NOT EXECUTED
stop = (*routine)( &fsn->entry, routine_arg );
4000e4c4: 90 07 60 08 add %i5, 8, %o0
<== NOT EXECUTED
4000e4c8: 9f c6 00 00 call %i0
<== NOT EXECUTED
4000e4cc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000e4d0: fa 07 40 00 ld [ %i5 ], %i5
<== NOT EXECUTED
for (
4000e4d4: 80 a7 40 1b cmp %i5, %i3
<== NOT EXECUTED
4000e4d8: 12 bf ff f8 bne 4000e4b8 <rtems_filesystem_iterate+0x78>
<== NOT EXECUTED
4000e4dc: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
rtems_libio_unlock();
4000e4e0: 7f ff d9 1d call 40004954 <rtems_libio_unlock>
<== NOT EXECUTED
4000e4e4: b8 0f 20 ff and %i4, 0xff, %i4
<== NOT EXECUTED
}
4000e4e8: 81 c7 e0 08 ret
4000e4ec: 91 e8 00 1c restore %g0, %i4, %o0
4000e18c <rtems_filesystem_location_clone>:
void rtems_filesystem_location_clone(
rtems_filesystem_location_info_t *clone,
const rtems_filesystem_location_info_t *master
)
{
4000e18c: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
clone = rtems_filesystem_location_copy( clone, master );
4000e190: 92 10 00 19 mov %i1, %o1
4000e194: 7f ff de 94 call 40005be4 <rtems_filesystem_location_copy>
4000e198: 90 10 00 18 mov %i0, %o0
rv = (*clone->mt_entry->ops->clonenod_h)( clone );
4000e19c: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000e1a0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4000e1a4: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
4000e1a8: 9f c0 40 00 call %g1
4000e1ac: ba 10 00 08 mov %o0, %i5
if ( rv != 0 ) {
4000e1b0: 80 a2 20 00 cmp %o0, 0
4000e1b4: 12 80 00 04 bne 4000e1c4 <rtems_filesystem_location_clone+0x38>
<== NEVER TAKEN
4000e1b8: 90 10 00 1d mov %i5, %o0
rtems_filesystem_location_remove_from_mt_entry( clone );
rtems_filesystem_location_initialize_to_null( clone );
}
}
4000e1bc: 81 c7 e0 08 ret
4000e1c0: 81 e8 00 00 restore
return rtems_filesystem_location_copy(
4000e1c4: 33 10 00 49 sethi %hi(0x40012400), %i1
<== NOT EXECUTED
rtems_filesystem_location_remove_from_mt_entry( clone );
4000e1c8: 7f ff df 5b call 40005f34 <rtems_filesystem_location_remove_from_mt_entry>
<== NOT EXECUTED
4000e1cc: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
4000e1d0: 7f ff de 85 call 40005be4 <rtems_filesystem_location_copy>
<== NOT EXECUTED
4000e1d4: 93 ee 63 18 restore %i1, 0x318, %o1
<== NOT EXECUTED
40005be4 <rtems_filesystem_location_copy>:
rtems_filesystem_location_info_t *rtems_filesystem_location_copy(
rtems_filesystem_location_info_t *dst,
const rtems_filesystem_location_info_t *src
)
{
dst->node_access = src->node_access;
40005be4: da 02 60 08 ld [ %o1 + 8 ], %o5
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40005be8: c8 02 60 0c ld [ %o1 + 0xc ], %g4
<== NOT EXECUTED
dst->handlers = src->handlers;
40005bec: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40005bf0: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
<== NOT EXECUTED
40005bf4: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
40005bf8: da 22 20 08 st %o5, [ %o0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40005bfc: c8 22 20 0c st %g4, [ %o0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40005c00: c6 22 20 10 st %g3, [ %o0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005c04: 91 d0 20 09 ta 9
<== NOT EXECUTED
&loc->mt_entry->location_chain,
40005c08: c6 02 20 14 ld [ %o0 + 0x14 ], %g3
<== NOT EXECUTED
old_last = tail->previous;
40005c0c: c8 00 e0 1c ld [ %g3 + 0x1c ], %g4
<== NOT EXECUTED
return &the_chain->Tail.Node;
40005c10: 9a 00 e0 18 add %g3, 0x18, %o5
<== NOT EXECUTED
the_node->next = tail;
40005c14: da 22 00 00 st %o5, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
40005c18: d0 20 e0 1c st %o0, [ %g3 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40005c1c: d0 21 00 00 st %o0, [ %g4 ]
<== NOT EXECUTED
the_node->previous = old_last;
40005c20: c8 22 20 04 st %g4, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005c24: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005c28: 01 00 00 00 nop
rtems_chain_initialize_node(&dst->mt_entry_node);
rtems_filesystem_location_add_to_mt_entry(dst);
return dst;
}
40005c2c: 81 c3 e0 08 retl
40005c30: 01 00 00 00 nop
40005fb8 <rtems_filesystem_location_copy_and_detach>:
{
40005fb8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
dst->node_access = src->node_access;
40005fbc: c8 06 60 08 ld [ %i1 + 8 ], %g4
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40005fc0: c6 06 60 0c ld [ %i1 + 0xc ], %g3
<== NOT EXECUTED
dst->handlers = src->handlers;
40005fc4: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40005fc8: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
<== NOT EXECUTED
40005fcc: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
40005fd0: c8 26 20 08 st %g4, [ %i0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40005fd4: c6 26 20 0c st %g3, [ %i0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40005fd8: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005fdc: 91 d0 20 09 ta 9
<== NOT EXECUTED
&loc->mt_entry->location_chain,
40005fe0: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
40005fe4: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40005fe8: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40005fec: c8 26 00 00 st %g4, [ %i0 ]
<== NOT EXECUTED
tail->previous = the_node;
40005ff0: f0 20 a0 1c st %i0, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40005ff4: f0 20 c0 00 st %i0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40005ff8: c6 26 20 04 st %g3, [ %i0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005ffc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006000: 01 00 00 00 nop
rtems_filesystem_location_remove_from_mt_entry(detach);
40006004: 7f ff ff cc call 40005f34 <rtems_filesystem_location_remove_from_mt_entry>
40006008: 90 10 00 19 mov %i1, %o0
dst->node_access = src->node_access;
4000600c: 03 10 00 49 sethi %hi(0x40012400), %g1
<== NOT EXECUTED
40006010: 82 10 63 18 or %g1, 0x318, %g1 ! 40012718 <rtems_filesystem_global_location_null>
<== NOT EXECUTED
40006014: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
40006018: c4 26 60 08 st %g2, [ %i1 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
4000601c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
40006020: c4 26 60 0c st %g2, [ %i1 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40006024: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40006028: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
4000602c: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40006030: c4 26 60 10 st %g2, [ %i1 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006034: 91 d0 20 09 ta 9
<== NOT EXECUTED
40006038: c4 06 60 14 ld [ %i1 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
4000603c: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40006040: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40006044: c8 26 40 00 st %g4, [ %i1 ]
<== NOT EXECUTED
tail->previous = the_node;
40006048: f2 20 a0 1c st %i1, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
4000604c: f2 20 c0 00 st %i1, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40006050: c6 26 60 04 st %g3, [ %i1 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006054: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006058: 01 00 00 00 nop
}
4000605c: 81 c7 e0 08 ret
40006060: 81 e8 00 00 restore
40005c34 <rtems_filesystem_location_detach>:
void rtems_filesystem_location_detach(
rtems_filesystem_location_info_t *detach
)
{
40005c34: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_filesystem_location_free(detach);
40005c38: 40 00 21 68 call 4000e1d8 <rtems_filesystem_location_free>
<== NOT EXECUTED
40005c3c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
dst->node_access = src->node_access;
40005c40: 03 10 00 49 sethi %hi(0x40012400), %g1
<== NOT EXECUTED
40005c44: 82 10 63 18 or %g1, 0x318, %g1 ! 40012718 <rtems_filesystem_global_location_null>
<== NOT EXECUTED
40005c48: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
40005c4c: c4 26 20 08 st %g2, [ %i0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40005c50: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
40005c54: c4 26 20 0c st %g2, [ %i0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40005c58: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40005c5c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
40005c60: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40005c64: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005c68: 91 d0 20 09 ta 9
<== NOT EXECUTED
40005c6c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
40005c70: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40005c74: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40005c78: c8 26 00 00 st %g4, [ %i0 ]
<== NOT EXECUTED
tail->previous = the_node;
40005c7c: f0 20 a0 1c st %i0, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40005c80: f0 20 c0 00 st %i0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40005c84: c6 26 20 04 st %g3, [ %i0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005c88: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005c8c: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_initialize_to_null(detach);
}
40005c90: 81 c7 e0 08 ret
<== NOT EXECUTED
40005c94: 81 e8 00 00 restore
<== NOT EXECUTED
4000e1d8 <rtems_filesystem_location_free>:
#endif
#include <rtems/libio_.h>
void rtems_filesystem_location_free( rtems_filesystem_location_info_t *loc )
{
4000e1d8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
4000e1dc: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
4000e1e0: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
4000e1e4: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
4000e1e8: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e1ec: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_instance_lock( loc );
(*loc->mt_entry->ops->freenod_h)( loc );
4000e1f0: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
4000e1f4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
4000e1f8: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
<== NOT EXECUTED
4000e1fc: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e200: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
4000e204: d0 06 20 14 ld [ %i0 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
4000e208: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
4000e20c: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
4000e210: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000e214: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_instance_unlock( loc );
rtems_filesystem_location_remove_from_mt_entry( loc );
4000e218: 7f ff df 47 call 40005f34 <rtems_filesystem_location_remove_from_mt_entry>
<== NOT EXECUTED
4000e21c: 81 e8 00 00 restore
<== NOT EXECUTED
40005f34 <rtems_filesystem_location_remove_from_mt_entry>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005f34: 91 d0 20 09 ta 9
<== NOT EXECUTED
previous = the_node->previous;
40005f38: c6 02 20 04 ld [ %o0 + 4 ], %g3
next = the_node->next;
40005f3c: c8 02 00 00 ld [ %o0 ], %g4
next->previous = previous;
40005f40: c6 21 20 04 st %g3, [ %g4 + 4 ]
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
40005f44: c4 02 20 14 ld [ %o0 + 0x14 ], %g2
previous->next = next;
40005f48: c8 20 c0 00 st %g4, [ %g3 ]
40005f4c: c6 08 a0 28 ldub [ %g2 + 0x28 ], %g3
40005f50: 80 a0 e0 00 cmp %g3, 0
40005f54: 12 80 00 07 bne 40005f70 <rtems_filesystem_location_remove_from_mt_entry+0x3c>
<== ALWAYS TAKEN
40005f58: 01 00 00 00 nop
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
40005f5c: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
<== NOT EXECUTED
40005f60: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
40005f64: 80 a1 00 03 cmp %g4, %g3
<== NOT EXECUTED
40005f68: 22 80 00 06 be,a 40005f80 <rtems_filesystem_location_remove_from_mt_entry+0x4c>
<== NOT EXECUTED
40005f6c: c6 00 a0 24 ld [ %g2 + 0x24 ], %g3
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005f70: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005f74: 01 00 00 00 nop
}
40005f78: 81 c3 e0 08 retl
40005f7c: 01 00 00 00 nop
&& mt_entry->mt_fs_root->reference_count == 1;
40005f80: c6 00 e0 18 ld [ %g3 + 0x18 ], %g3
<== NOT EXECUTED
40005f84: 80 a0 e0 01 cmp %g3, 1
<== NOT EXECUTED
40005f88: 12 bf ff fa bne 40005f70 <rtems_filesystem_location_remove_from_mt_entry+0x3c>
<== NOT EXECUTED
40005f8c: 86 00 a0 14 add %g2, 0x14, %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40005f90: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
head->previous = NULL;
40005f94: c0 20 a0 18 clr [ %g2 + 0x18 ]
<== NOT EXECUTED
head->next = tail;
40005f98: c8 20 a0 14 st %g4, [ %g2 + 0x14 ]
<== NOT EXECUTED
tail->previous = head;
40005f9c: c6 20 a0 1c st %g3, [ %g2 + 0x1c ]
<== NOT EXECUTED
40005fa0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005fa4: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_do_unmount(loc->mt_entry);
40005fa8: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
<== NOT EXECUTED
40005fac: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40005fb0: 7f ff ff 3a call 40005c98 <rtems_filesystem_do_unmount>
<== NOT EXECUTED
40005fb4: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40006064 <rtems_filesystem_location_transform_to_global>:
{
40006064: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
40006068: 7f ff fa d1 call 40004bac <malloc>
<== NOT EXECUTED
4000606c: 90 10 20 24 mov 0x24, %o0
<== NOT EXECUTED
if (global_loc != NULL) {
40006070: ba 92 20 00 orcc %o0, 0, %i5
<== NOT EXECUTED
40006074: 02 80 00 1c be 400060e4 <rtems_filesystem_location_transform_to_global+0x80>
<== NOT EXECUTED
40006078: b8 10 20 01 mov 1, %i4
<== NOT EXECUTED
dst->node_access = src->node_access;
4000607c: c8 06 20 08 ld [ %i0 + 8 ], %g4
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40006080: c6 06 20 0c ld [ %i0 + 0xc ], %g3
<== NOT EXECUTED
dst->handlers = src->handlers;
40006084: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40006088: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
global_loc->deferred_released_next = NULL;
4000608c: c0 27 60 1c clr [ %i5 + 0x1c ]
<== NOT EXECUTED
global_loc->reference_count = 1;
40006090: f8 27 60 18 st %i4, [ %i5 + 0x18 ]
<== NOT EXECUTED
global_loc->deferred_released_count = 0;
40006094: c0 27 60 20 clr [ %i5 + 0x20 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
40006098: c8 27 60 08 st %g4, [ %i5 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
4000609c: c6 27 60 0c st %g3, [ %i5 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
400060a0: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
400060a4: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400060a8: 91 d0 20 09 ta 9
<== NOT EXECUTED
400060ac: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
400060b0: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
400060b4: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
400060b8: c8 27 40 00 st %g4, [ %i5 ]
<== NOT EXECUTED
tail->previous = the_node;
400060bc: fa 20 a0 1c st %i5, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
400060c0: fa 20 c0 00 st %i5, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
400060c4: c6 27 60 04 st %g3, [ %i5 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400060c8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400060cc: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_remove_from_mt_entry(loc);
400060d0: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400060d4: 7f ff ff 98 call 40005f34 <rtems_filesystem_location_remove_from_mt_entry>
<== NOT EXECUTED
400060d8: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
400060dc: 81 c7 e0 08 ret
<== NOT EXECUTED
400060e0: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_location_free(loc);
400060e4: 40 00 20 3d call 4000e1d8 <rtems_filesystem_location_free>
<== NOT EXECUTED
400060e8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
400060ec: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
400060f0: 7f ff ff 33 call 40005dbc <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
400060f4: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
errno = ENOMEM;
400060f8: 40 00 24 41 call 4000f1fc <__errno>
<== NOT EXECUTED
400060fc: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
40006100: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40006104: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40006108: 81 c7 e0 08 ret
<== NOT EXECUTED
4000610c: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
40004c18 <rtems_filesystem_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40004c18: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
40004c1c: 40 00 01 e3 call 400053a8 <rtems_current_user_env_get>
40004c20: 01 00 00 00 nop
40004c24: d6 02 20 08 ld [ %o0 + 8 ], %o3
40004c28: 96 2e c0 0b andn %i3, %o3, %o3
switch (mode & S_IFMT) {
40004c2c: 03 00 00 3c sethi %hi(0xf000), %g1
40004c30: 05 00 00 10 sethi %hi(0x4000), %g2
40004c34: 82 0a c0 01 and %o3, %g1, %g1
40004c38: 80 a0 40 02 cmp %g1, %g2
40004c3c: 22 80 00 0c be,a 40004c6c <rtems_filesystem_mknod+0x54>
<== ALWAYS TAKEN
40004c40: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40004c44: 08 80 00 14 bleu 40004c94 <rtems_filesystem_mknod+0x7c>
<== NOT EXECUTED
40004c48: 05 00 00 04 sethi %hi(0x1000), %g2
<== NOT EXECUTED
40004c4c: 05 00 00 18 sethi %hi(0x6000), %g2
<== NOT EXECUTED
40004c50: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40004c54: 02 80 00 05 be 40004c68 <rtems_filesystem_mknod+0x50>
<== NOT EXECUTED
40004c58: 05 00 00 20 sethi %hi(0x8000), %g2
<== NOT EXECUTED
40004c5c: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40004c60: 12 80 00 13 bne 40004cac <rtems_filesystem_mknod+0x94>
<== NOT EXECUTED
40004c64: 01 00 00 00 nop
<== NOT EXECUTED
rv = -1;
break;
}
if ( rv == 0 ) {
const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops;
40004c68: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
40004c6c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40004c70: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40004c74: 98 10 00 1c mov %i4, %o4
40004c78: 9a 10 00 1d mov %i5, %o5
40004c7c: 94 10 00 1a mov %i2, %o2
40004c80: 92 10 00 19 mov %i1, %o1
40004c84: 9f c0 40 00 call %g1
40004c88: 90 10 00 18 mov %i0, %o0
40004c8c: 81 c7 e0 08 ret
40004c90: 91 e8 00 08 restore %g0, %o0, %o0
switch (mode & S_IFMT) {
40004c94: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40004c98: 02 bf ff f4 be 40004c68 <rtems_filesystem_mknod+0x50>
<== NOT EXECUTED
40004c9c: 05 00 00 08 sethi %hi(0x2000), %g2
<== NOT EXECUTED
40004ca0: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40004ca4: 22 bf ff f2 be,a 40004c6c <rtems_filesystem_mknod+0x54>
<== NOT EXECUTED
40004ca8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
errno = EINVAL;
40004cac: 40 00 29 54 call 4000f1fc <__errno>
<== NOT EXECUTED
40004cb0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004cb4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40004cb8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
return rv;
}
40004cbc: 81 c7 e0 08 ret
<== NOT EXECUTED
40004cc0: 81 e8 00 00 restore
<== NOT EXECUTED
40010d20 <rtems_filesystem_null_handlers>:
40010d20: 40 00 62 70 40 00 db cc 40 00 de 20 40 00 de b8 @.bp@...@.. @...
40010d30: 40 00 dc 54 40 00 dd d8 40 00 62 78 40 00 dc 38 @..T@...@.bx@..8
40010d40: 40 00 db f8 40 00 db f8 40 00 db e8 40 00 de 18 @...@...@...@...
40010d50: 40 00 dc 70 40 00 de 3c 40 00 de d4 40 00 dd f4 @..p@..<@...@...
40010d60: 3f 00 00 00 00 00 00 00 52 54 45 4d 53 5f 53 55 ?.......RTEMS_SU
40010d70: 43 43 45 53 53 46 55 4c 00 00 00 00 00 00 00 00 CCESSFUL........
40010d80: 52 54 45 4d 53 5f 54 41 53 4b 5f 45 58 49 54 54 RTEMS_TASK_EXITT
40010d90: 45 44 00 00 00 00 00 00 52 54 45 4d 53 5f 4d 50 ED......RTEMS_MP
40010da0: 5f 4e 4f 54 5f 43 4f 4e 46 49 47 55 52 45 44 00 _NOT_CONFIGURED.
40010db0: 52 54 45 4d 53 5f 49 4e 56 41 4c 49 44 5f 4e 41 RTEMS_INVALID_NA
40010dc0: 4d 45 00 00 00 00 00 00 52 54 45 4d 53 5f 49 4e ME......RTEMS_IN
40010dd0: 56 41 4c 49 44 5f 49 44 00 00 00 00 00 00 00 00 VALID_ID........
40010de0: 52 54 45 4d 53 5f 54 4f 4f 5f 4d 41 4e 59 00 00 RTEMS_TOO_MANY..
40010df0: 52 54 45 4d 53 5f 54 49 4d 45 4f 55 54 00 00 00 RTEMS_TIMEOUT...
40010e00: 52 54 45 4d 53 5f 4f 42 4a 45 43 54 5f 57 41 53 RTEMS_OBJECT_WAS
40010e10: 5f 44 45 4c 45 54 45 44 00 00 00 00 00 00 00 00 _DELETED........
40010e20: 52 54 45 4d 53 5f 49 4e 56 41 4c 49 44 5f 53 49 RTEMS_INVALID_SI
40010e30: 5a 45 00 00 00 00 00 00 52 54 45 4d 53 5f 49 4e ZE......RTEMS_IN
40010e40: 56 41 4c 49 44 5f 41 44 44 52 45 53 53 00 00 00 VALID_ADDRESS...
40010e50: 52 54 45 4d 53 5f 49 4e 56 41 4c 49 44 5f 4e 55 RTEMS_INVALID_NU
40010e60: 4d 42 45 52 00 00 00 00 52 54 45 4d 53 5f 4e 4f MBER....RTEMS_NO
40010e70: 54 5f 44 45 46 49 4e 45 44 00 00 00 00 00 00 00 T_DEFINED.......
40010e80: 52 54 45 4d 53 5f 52 45 53 4f 55 52 43 45 5f 49 RTEMS_RESOURCE_I
40010e90: 4e 5f 55 53 45 00 00 00 52 54 45 4d 53 5f 55 4e N_USE...RTEMS_UN
40010ea0: 53 41 54 49 53 46 49 45 44 00 00 00 00 00 00 00 SATISFIED.......
40010eb0: 52 54 45 4d 53 5f 49 4e 43 4f 52 52 45 43 54 5f RTEMS_INCORRECT_
40010ec0: 53 54 41 54 45 00 00 00 52 54 45 4d 53 5f 41 4c STATE...RTEMS_AL
40010ed0: 52 45 41 44 59 5f 53 55 53 50 45 4e 44 45 44 00 READY_SUSPENDED.
40010ee0: 52 54 45 4d 53 5f 49 4c 4c 45 47 41 4c 5f 4f 4e RTEMS_ILLEGAL_ON
40010ef0: 5f 53 45 4c 46 00 00 00 52 54 45 4d 53 5f 49 4c _SELF...RTEMS_IL
40010f00: 4c 45 47 41 4c 5f 4f 4e 5f 52 45 4d 4f 54 45 5f LEGAL_ON_REMOTE_
40010f10: 4f 42 4a 45 43 54 00 00 52 54 45 4d 53 5f 43 41 OBJECT..RTEMS_CA
40010f20: 4c 4c 45 44 5f 46 52 4f 4d 5f 49 53 52 00 00 00 LLED_FROM_ISR...
40010f30: 52 54 45 4d 53 5f 49 4e 56 41 4c 49 44 5f 50 52 RTEMS_INVALID_PR
40010f40: 49 4f 52 49 54 59 00 00 52 54 45 4d 53 5f 49 4e IORITY..RTEMS_IN
40010f50: 56 41 4c 49 44 5f 43 4c 4f 43 4b 00 00 00 00 00 VALID_CLOCK.....
40010f60: 52 54 45 4d 53 5f 49 4e 56 41 4c 49 44 5f 4e 4f RTEMS_INVALID_NO
40010f70: 44 45 00 00 00 00 00 00 52 54 45 4d 53 5f 4e 4f DE......RTEMS_NO
40010f80: 54 5f 43 4f 4e 46 49 47 55 52 45 44 00 00 00 00 T_CONFIGURED....
40010f90: 52 54 45 4d 53 5f 4e 4f 54 5f 4f 57 4e 45 52 5f RTEMS_NOT_OWNER_
40010fa0: 4f 46 5f 52 45 53 4f 55 52 43 45 00 00 00 00 00 OF_RESOURCE.....
40010fb0: 52 54 45 4d 53 5f 4e 4f 54 5f 49 4d 50 4c 45 4d RTEMS_NOT_IMPLEM
40010fc0: 45 4e 54 45 44 00 00 00 52 54 45 4d 53 5f 49 4e ENTED...RTEMS_IN
40010fd0: 54 45 52 4e 41 4c 5f 45 52 52 4f 52 00 00 00 00 TERNAL_ERROR....
40010fe0: 52 54 45 4d 53 5f 4e 4f 5f 4d 45 4d 4f 52 59 00 RTEMS_NO_MEMORY.
40010ff0: 52 54 45 4d 53 5f 49 4f 5f 45 52 52 4f 52 00 00 RTEMS_IO_ERROR..
40011000: 52 54 45 4d 53 5f 50 52 4f 58 59 5f 42 4c 4f 43 RTEMS_PROXY_BLOC
40011010: 4b 49 4e 47 00 00 00 00 KING....
40004a08 <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
40004a08: 9d e3 bf a0 save %sp, -96, %sp
40004a0c: 03 10 00 4f sethi %hi(0x40013c00), %g1
40004a10: c2 00 62 3c ld [ %g1 + 0x23c ], %g1 ! 40013e3c <_System_state_Current>
Heap_Control *heap = RTEMS_Malloc_Heap;
40004a14: 05 10 00 49 sethi %hi(0x40012400), %g2
if ( _System_state_Is_up( state ) ) {
40004a18: 80 a0 60 02 cmp %g1, 2
40004a1c: 02 80 00 21 be 40004aa0 <rtems_heap_allocate_aligned_with_boundary+0x98>
<== NEVER TAKEN
40004a20: f8 00 a2 8c ld [ %g2 + 0x28c ], %i4
} else if ( _System_state_Is_before_multitasking( state ) ) {
40004a24: 80 a0 60 01 cmp %g1, 1
40004a28: 02 80 00 22 be 40004ab0 <rtems_heap_allocate_aligned_with_boundary+0xa8>
40004a2c: 96 10 00 1a mov %i2, %o3
boundary
);
_RTEMS_Unlock_allocator();
break;
case MALLOC_SYSTEM_STATE_NO_PROTECTION:
p = _Heap_Allocate_aligned_with_boundary(
40004a30: 94 10 00 19 mov %i1, %o2
40004a34: 92 10 00 18 mov %i0, %o1
40004a38: 40 00 0c 17 call 40007a94 <_Heap_Allocate_aligned_with_boundary>
40004a3c: 90 10 00 1c mov %i4, %o0
40004a40: ba 10 00 08 mov %o0, %i5
* Do not attempt to allocate memory if not in correct system state.
*/
return NULL;
}
if ( p == NULL && alignment == 0 && boundary == 0 ) {
40004a44: 80 a7 60 00 cmp %i5, 0
40004a48: 12 80 00 0b bne 40004a74 <rtems_heap_allocate_aligned_with_boundary+0x6c>
<== ALWAYS TAKEN
40004a4c: 80 a6 60 00 cmp %i1, 0
40004a50: 12 80 00 09 bne 40004a74 <rtems_heap_allocate_aligned_with_boundary+0x6c>
<== NOT EXECUTED
40004a54: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40004a58: 12 80 00 23 bne 40004ae4 <rtems_heap_allocate_aligned_with_boundary+0xdc>
<== NOT EXECUTED
40004a5c: 03 10 00 42 sethi %hi(0x40010800), %g1
<== NOT EXECUTED
p = (*rtems_malloc_extend_handler)( heap, size );
40004a60: c2 00 60 7c ld [ %g1 + 0x7c ], %g1 ! 4001087c <rtems_malloc_extend_handler>
<== NOT EXECUTED
40004a64: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
40004a68: 9f c0 40 00 call %g1
<== NOT EXECUTED
40004a6c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40004a70: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( p != NULL && rtems_malloc_dirty_helper != NULL )
40004a74: 80 a7 60 00 cmp %i5, 0
40004a78: 02 80 00 1b be 40004ae4 <rtems_heap_allocate_aligned_with_boundary+0xdc>
<== NEVER TAKEN
40004a7c: 03 10 00 4a sethi %hi(0x40012800), %g1
40004a80: c2 00 62 d8 ld [ %g1 + 0x2d8 ], %g1 ! 40012ad8 <rtems_malloc_dirty_helper>
40004a84: 80 a0 60 00 cmp %g1, 0
40004a88: 02 80 00 04 be 40004a98 <rtems_heap_allocate_aligned_with_boundary+0x90>
<== ALWAYS TAKEN
40004a8c: 92 10 00 18 mov %i0, %o1
(*rtems_malloc_dirty_helper)( p, size );
40004a90: 9f c0 40 00 call %g1
<== NOT EXECUTED
40004a94: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
return p;
}
40004a98: 81 c7 e0 08 ret
40004a9c: 91 e8 00 1d restore %g0, %i5, %o0
40004aa0: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
<== NOT EXECUTED
if ( _Thread_Dispatch_is_enabled() ) {
40004aa4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40004aa8: 32 80 00 10 bne,a 40004ae8 <rtems_heap_allocate_aligned_with_boundary+0xe0>
<== NOT EXECUTED
40004aac: ba 10 20 00 clr %i5
<== NOT EXECUTED
_RTEMS_Lock_allocator();
40004ab0: 40 00 0b 67 call 4000784c <_RTEMS_Lock_allocator>
40004ab4: 01 00 00 00 nop
_Malloc_Process_deferred_frees();
40004ab8: 7f ff ff bb call 400049a4 <_Malloc_Process_deferred_frees>
40004abc: 01 00 00 00 nop
p = _Heap_Allocate_aligned_with_boundary(
40004ac0: 96 10 00 1a mov %i2, %o3
40004ac4: 94 10 00 19 mov %i1, %o2
40004ac8: 92 10 00 18 mov %i0, %o1
40004acc: 40 00 0b f2 call 40007a94 <_Heap_Allocate_aligned_with_boundary>
40004ad0: 90 10 00 1c mov %i4, %o0
_RTEMS_Unlock_allocator();
40004ad4: 40 00 0b 63 call 40007860 <_RTEMS_Unlock_allocator>
40004ad8: ba 10 00 08 mov %o0, %i5
break;
40004adc: 10 bf ff db b 40004a48 <rtems_heap_allocate_aligned_with_boundary+0x40>
40004ae0: 80 a7 60 00 cmp %i5, 0
return NULL;
40004ae4: ba 10 20 00 clr %i5
<== NOT EXECUTED
}
40004ae8: 81 c7 e0 08 ret
<== NOT EXECUTED
40004aec: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
400053fc <rtems_heap_null_extend>:
Heap_Control *heap RTEMS_UNUSED,
size_t alloc_size RTEMS_UNUSED
)
{
return NULL;
}
400053fc: 81 c3 e0 08 retl
<== NOT EXECUTED
40005400: 90 10 20 00 clr %o0 ! 0 <PROM_START>
<== NOT EXECUTED
4000e378 <rtems_libio_allocate>:
return fcntl_flags;
}
rtems_libio_t *rtems_libio_allocate( void )
{
4000e378: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_lock();
4000e37c: 7f ff d9 71 call 40004940 <rtems_libio_lock>
4000e380: 01 00 00 00 nop
iop = rtems_libio_iop_free_head;
4000e384: 03 10 00 4f sethi %hi(0x40013c00), %g1
4000e388: f0 00 61 5c ld [ %g1 + 0x15c ], %i0 ! 40013d5c <rtems_libio_iop_free_head>
if ( iop != NULL ) {
4000e38c: 80 a6 20 00 cmp %i0, 0
4000e390: 02 80 00 06 be 4000e3a8 <rtems_libio_allocate+0x30>
<== NEVER TAKEN
4000e394: 86 10 61 5c or %g1, 0x15c, %g3
void *next;
next = iop->data1;
4000e398: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
rtems_libio_iop_free_head = next;
if ( next == NULL ) {
4000e39c: 80 a0 a0 00 cmp %g2, 0
4000e3a0: 02 80 00 06 be 4000e3b8 <rtems_libio_allocate+0x40>
4000e3a4: c4 20 61 5c st %g2, [ %g1 + 0x15c ]
rtems_libio_iop_free_tail = &rtems_libio_iop_free_head;
}
}
rtems_libio_unlock();
4000e3a8: 7f ff d9 6b call 40004954 <rtems_libio_unlock>
4000e3ac: 01 00 00 00 nop
return iop;
}
4000e3b0: 81 c7 e0 08 ret
4000e3b4: 81 e8 00 00 restore
rtems_libio_iop_free_tail = &rtems_libio_iop_free_head;
4000e3b8: 03 10 00 49 sethi %hi(0x40012400), %g1
rtems_libio_unlock();
4000e3bc: 7f ff d9 66 call 40004954 <rtems_libio_unlock>
4000e3c0: c6 20 62 98 st %g3, [ %g1 + 0x298 ] ! 40012698 <rtems_libio_iop_free_tail>
}
4000e3c4: 81 c7 e0 08 ret
4000e3c8: 81 e8 00 00 restore
4000e324 <rtems_libio_exit>:
#include <unistd.h>
#include <rtems/libio.h>
void rtems_libio_exit(void)
{
4000e324: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
(void)close(0);
4000e328: 40 00 03 78 call 4000f108 <close>
<== NOT EXECUTED
4000e32c: 90 10 20 00 clr %o0
<== NOT EXECUTED
(void)close(1);
(void)close(2);
4000e330: b0 10 20 02 mov 2, %i0
<== NOT EXECUTED
(void)close(1);
4000e334: 40 00 03 75 call 4000f108 <close>
<== NOT EXECUTED
4000e338: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
(void)close(2);
4000e33c: 40 00 03 73 call 4000f108 <close>
<== NOT EXECUTED
4000e340: 81 e8 00 00 restore
<== NOT EXECUTED
4000e3cc <rtems_libio_free>:
void rtems_libio_free(
rtems_libio_t *iop
)
{
4000e3cc: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
rtems_filesystem_location_free( &iop->pathinfo );
4000e3d0: 7f ff ff 82 call 4000e1d8 <rtems_filesystem_location_free>
<== NOT EXECUTED
4000e3d4: 90 06 20 0c add %i0, 0xc, %o0
<== NOT EXECUTED
rtems_libio_lock();
4000e3d8: 7f ff d9 5a call 40004940 <rtems_libio_lock>
<== NOT EXECUTED
4000e3dc: 01 00 00 00 nop
<== NOT EXECUTED
iop = memset( iop, 0, sizeof( *iop ) );
4000e3e0: 94 10 20 30 mov 0x30, %o2 ! 30 <_TLS_Alignment+0x2f>
<== NOT EXECUTED
4000e3e4: 92 10 20 00 clr %o1
<== NOT EXECUTED
4000e3e8: 40 00 03 ef call 4000f3a4 <memset>
<== NOT EXECUTED
4000e3ec: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
*rtems_libio_iop_free_tail = iop;
4000e3f0: 03 10 00 49 sethi %hi(0x40012400), %g1
<== NOT EXECUTED
4000e3f4: c4 00 62 98 ld [ %g1 + 0x298 ], %g2 ! 40012698 <rtems_libio_iop_free_tail>
<== NOT EXECUTED
4000e3f8: d0 20 80 00 st %o0, [ %g2 ]
<== NOT EXECUTED
rtems_libio_iop_free_tail = &iop->data1;
4000e3fc: 90 02 20 28 add %o0, 0x28, %o0
<== NOT EXECUTED
4000e400: d0 20 62 98 st %o0, [ %g1 + 0x298 ]
<== NOT EXECUTED
rtems_libio_unlock();
4000e404: 7f ff d9 54 call 40004954 <rtems_libio_unlock>
<== NOT EXECUTED
4000e408: 81 e8 00 00 restore
<== NOT EXECUTED
400053d4 <rtems_libio_free_user_env>:
if (!uses_global_env) {
400053d4: 03 10 00 49 sethi %hi(0x40012400), %g1
<== NOT EXECUTED
400053d8: 82 10 62 d0 or %g1, 0x2d0, %g1 ! 400126d0 <rtems_global_user_env>
<== NOT EXECUTED
400053dc: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
400053e0: 02 80 00 05 be 400053f4 <rtems_libio_free_user_env+0x20>
<== NOT EXECUTED
400053e4: 01 00 00 00 nop
<== NOT EXECUTED
400053e8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400053ec: 7f ff ff e6 call 40005384 <rtems_libio_free_user_env.part.1>
<== NOT EXECUTED
400053f0: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
}
}
400053f4: 81 c3 e0 08 retl
<== NOT EXECUTED
400053f8: 01 00 00 00 nop
<== NOT EXECUTED
400050c4 <rtems_libio_post_driver>:
/*
* This is a replaceable stub which opens the console, if present.
*/
void rtems_libio_post_driver(void)
{
400050c4: 9d e3 bf a0 save %sp, -96, %sp
/*
* Attempt to open /dev/console.
*/
if ( open( CONSOLE_DEVICE_NAME, O_RDONLY, 0 ) != STDIN_FILENO ) {
400050c8: 94 10 20 00 clr %o2
400050cc: 92 10 20 00 clr %o1
400050d0: 3b 10 00 43 sethi %hi(0x40010c00), %i5
400050d4: 40 00 00 1a call 4000513c <open>
400050d8: 90 17 60 30 or %i5, 0x30, %o0 ! 40010c30 <IMFS_node_control_sym_link+0x1c>
400050dc: 80 a2 20 00 cmp %o0, 0
400050e0: 02 80 00 04 be 400050f0 <rtems_libio_post_driver+0x2c>
<== ALWAYS TAKEN
400050e4: 94 10 20 00 clr %o2
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDERR_FILENO ) {
_Internal_error( INTERNAL_ERROR_LIBIO_STDERR_FD_OPEN_FAILED );
}
atexit(rtems_libio_exit);
}
400050e8: 81 c7 e0 08 ret
<== NOT EXECUTED
400050ec: 81 e8 00 00 restore
<== NOT EXECUTED
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDOUT_FILENO ) {
400050f0: 92 10 20 01 mov 1, %o1
400050f4: 40 00 00 12 call 4000513c <open>
400050f8: 90 17 60 30 or %i5, 0x30, %o0
400050fc: 80 a2 20 01 cmp %o0, 1
40005100: 12 80 00 0a bne 40005128 <rtems_libio_post_driver+0x64>
<== NEVER TAKEN
40005104: 94 10 20 00 clr %o2
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDERR_FILENO ) {
40005108: 92 10 20 01 mov 1, %o1
4000510c: 40 00 00 0c call 4000513c <open>
40005110: 90 17 60 30 or %i5, 0x30, %o0
40005114: 80 a2 20 02 cmp %o0, 2
40005118: 12 80 00 06 bne 40005130 <rtems_libio_post_driver+0x6c>
<== NEVER TAKEN
4000511c: 31 10 00 38 sethi %hi(0x4000e000), %i0
<== NOT EXECUTED
atexit(rtems_libio_exit);
40005120: 40 00 28 30 call 4000f1e0 <atexit>
<== NOT EXECUTED
40005124: 91 ee 23 24 restore %i0, 0x324, %o0
_Internal_error( INTERNAL_ERROR_LIBIO_STDOUT_FD_OPEN_FAILED );
40005128: 40 00 0c 02 call 40008130 <_Internal_error>
<== NOT EXECUTED
4000512c: 90 10 20 24 mov 0x24, %o0
<== NOT EXECUTED
_Internal_error( INTERNAL_ERROR_LIBIO_STDERR_FD_OPEN_FAILED );
40005130: 40 00 0c 00 call 40008130 <_Internal_error>
<== NOT EXECUTED
40005134: 90 10 20 25 mov 0x25, %o0
<== NOT EXECUTED
40005138: 01 00 00 00 nop
<== NOT EXECUTED
4000e580 <rtems_printf>:
int rtems_printf(
const rtems_printer *printer,
const char *format,
...
)
{
4000e580: 9d e3 bf 98 save %sp, -104, %sp
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
va_list ap;
va_start( ap, format );
4000e584: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
{
4000e588: 82 10 00 18 mov %i0, %g1
va_start( ap, format );
4000e58c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int len = 0;
4000e590: b0 10 20 00 clr %i0
va_start( ap, format );
4000e594: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
4000e598: 80 a0 60 00 cmp %g1, 0
4000e59c: 02 80 00 0b be 4000e5c8 <rtems_printf+0x48>
<== NEVER TAKEN
4000e5a0: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
4000e5a4: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000e5a8: 80 a0 a0 00 cmp %g2, 0
4000e5ac: 02 80 00 07 be 4000e5c8 <rtems_printf+0x48>
<== NEVER TAKEN
4000e5b0: 94 07 a0 4c add %fp, 0x4c, %o2
len = printer->printer( printer->context, format, ap );
4000e5b4: d0 00 40 00 ld [ %g1 ], %o0
4000e5b8: 92 10 00 19 mov %i1, %o1
4000e5bc: 9f c0 80 00 call %g2
4000e5c0: d4 27 bf fc st %o2, [ %fp + -4 ]
4000e5c4: b0 10 00 08 mov %o0, %i0
va_end( ap );
}
return len;
}
4000e5c8: 81 c7 e0 08 ret
4000e5cc: 81 e8 00 00 restore
4000e544 <rtems_vprintf>:
int rtems_vprintf(
const rtems_printer *printer,
const char *format,
va_list ap
)
{
4000e544: 9d e3 bf a0 save %sp, -96, %sp
4000e548: 82 10 00 18 mov %i0, %g1
*
* @return true The printer is valid else false is returned.
*/
static inline bool rtems_print_printer_valid(const rtems_printer *printer)
{
return printer != NULL && printer->printer != NULL;
4000e54c: 80 a0 60 00 cmp %g1, 0
4000e550: 02 80 00 0a be 4000e578 <rtems_vprintf+0x34>
<== NEVER TAKEN
4000e554: b0 10 20 00 clr %i0
4000e558: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000e55c: 80 a0 a0 00 cmp %g2, 0
4000e560: 02 80 00 06 be 4000e578 <rtems_vprintf+0x34>
<== NEVER TAKEN
4000e564: 94 10 00 1a mov %i2, %o2
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
len = printer->printer( printer->context, format, ap );
4000e568: d0 00 40 00 ld [ %g1 ], %o0
4000e56c: 9f c0 80 00 call %g2
4000e570: 92 10 00 19 mov %i1, %o1
4000e574: b0 10 00 08 mov %o0, %i0
}
return len;
}
4000e578: 81 c7 e0 08 ret
4000e57c: 81 e8 00 00 restore