RTEMS-5
Annotated Report
Fri Aug 10 13:46:34 2018
400078a8 <RTEMS_Malloc_Initialize>:
void RTEMS_Malloc_Initialize(
const Heap_Area *areas,
size_t area_count,
Heap_Initialization_or_extend_handler extend
)
{
400078a8: 9d e3 bf a0 save %sp, -96, %sp
Heap_Control *heap = RTEMS_Malloc_Heap;
if ( !rtems_configuration_get_unified_work_area() ) {
400078ac: 03 10 00 8a sethi %hi(0x40022800), %g1
400078b0: c2 08 62 c1 ldub [ %g1 + 0x2c1 ], %g1 ! 40022ac1 <Configuration+0x31>
400078b4: 80 a0 60 00 cmp %g1, 0
400078b8: 12 80 00 19 bne 4000791c <RTEMS_Malloc_Initialize+0x74>
400078bc: 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) {
400078c0: 02 80 00 19 be 40007924 <RTEMS_Malloc_Initialize+0x7c>
<== NEVER TAKEN
400078c4: 03 10 00 94 sethi %hi(0x40025000), %g1
Heap_Control *heap = RTEMS_Malloc_Heap;
400078c8: f8 00 60 7c ld [ %g1 + 0x7c ], %i4 ! 4002507c <RTEMS_Malloc_Heap>
400078cc: b3 2e 60 03 sll %i1, 3, %i1
Heap_Initialization_or_extend_handler init_or_extend = _Heap_Initialize;
400078d0: 37 10 00 28 sethi %hi(0x4000a000), %i3
400078d4: b2 06 00 19 add %i0, %i1, %i1
400078d8: b6 16 e1 54 or %i3, 0x154, %i3
400078dc: ba 10 00 1b mov %i3, %i5
const Heap_Area *area = &areas [i];
uintptr_t space_available = (*init_or_extend)(
400078e0: d4 06 20 04 ld [ %i0 + 4 ], %o2
400078e4: d2 06 00 00 ld [ %i0 ], %o1
400078e8: 96 10 20 08 mov 8, %o3
400078ec: 9f c7 40 00 call %i5
400078f0: 90 10 00 1c mov %i4, %o0
area->begin,
area->size,
page_size
);
if ( space_available > 0 ) {
400078f4: 80 a2 20 00 cmp %o0, 0
400078f8: 32 80 00 02 bne,a 40007900 <RTEMS_Malloc_Initialize+0x58>
<== ALWAYS TAKEN
400078fc: ba 10 00 1a mov %i2, %i5
40007900: b0 06 20 08 add %i0, 8, %i0
for (i = 0; i < area_count; ++i) {
40007904: 80 a6 00 19 cmp %i0, %i1
40007908: 32 bf ff f7 bne,a 400078e4 <RTEMS_Malloc_Initialize+0x3c>
<== NEVER TAKEN
4000790c: d4 06 20 04 ld [ %i0 + 4 ], %o2
<== NOT EXECUTED
init_or_extend = extend;
}
}
if ( init_or_extend == _Heap_Initialize ) {
40007910: 80 a7 40 1b cmp %i5, %i3
40007914: 02 80 00 04 be 40007924 <RTEMS_Malloc_Initialize+0x7c>
<== NEVER TAKEN
40007918: 01 00 00 00 nop
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
}
}
}
4000791c: 81 c7 e0 08 ret
40007920: 81 e8 00 00 restore
_Internal_error( INTERNAL_ERROR_NO_MEMORY_FOR_HEAP );
40007924: 40 00 0b 1f call 4000a5a0 <_Internal_error>
<== NOT EXECUTED
40007928: 90 10 20 17 mov 0x17, %o0
<== NOT EXECUTED
4000792c: 01 00 00 00 nop
<== NOT EXECUTED
40007140 <_Console_simple_Read>:
ssize_t _Console_simple_Read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
40007140: 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 ) {
40007144: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40007148: 04 80 00 0c ble 40007178 <_Console_simple_Read+0x38>
<== NOT EXECUTED
4000714c: ba 10 20 00 clr %i5
<== NOT EXECUTED
int c;
do {
c = getchark();
40007150: 40 00 00 61 call 400072d4 <getchark>
<== NOT EXECUTED
40007154: 01 00 00 00 nop
<== NOT EXECUTED
} while (c == -1);
40007158: 80 a2 3f ff cmp %o0, -1
<== NOT EXECUTED
4000715c: 02 bf ff fd be 40007150 <_Console_simple_Read+0x10>
<== NOT EXECUTED
40007160: 01 00 00 00 nop
<== NOT EXECUTED
buf[ i ] = (char) c;
40007164: d0 2e 40 1d stb %o0, [ %i1 + %i5 ]
<== NOT EXECUTED
for ( i = 0; i < n; ++i ) {
40007168: ba 07 60 01 inc %i5
<== NOT EXECUTED
4000716c: 80 a6 80 1d cmp %i2, %i5
<== NOT EXECUTED
40007170: 12 bf ff f8 bne 40007150 <_Console_simple_Read+0x10>
<== NOT EXECUTED
40007174: 01 00 00 00 nop
<== NOT EXECUTED
}
return n;
}
40007178: 81 c7 e0 08 ret
<== NOT EXECUTED
4000717c: 91 e8 00 1a restore %g0, %i2, %o0
<== NOT EXECUTED
40007874 <_Malloc_Deferred_free>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007874: 91 d0 20 09 ta 9
<== NOT EXECUTED
old_last = tail->previous;
40007878: 05 10 00 94 sethi %hi(0x40025000), %g2
<== NOT EXECUTED
4000787c: 84 10 a0 cc or %g2, 0xcc, %g2 ! 400250cc <_Malloc_GC_list>
<== NOT EXECUTED
40007880: c6 00 a0 08 ld [ %g2 + 8 ], %g3
<== NOT EXECUTED
the_node->next = tail;
40007884: 88 00 a0 04 add %g2, 4, %g4
<== NOT EXECUTED
40007888: c8 22 00 00 st %g4, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
4000788c: d0 20 a0 08 st %o0, [ %g2 + 8 ]
<== NOT EXECUTED
old_last->next = the_node;
40007890: d0 20 c0 00 st %o0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40007894: c6 22 20 04 st %g3, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007898: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000789c: 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 );
}
400078a0: 81 c3 e0 08 retl
<== NOT EXECUTED
400078a4: 01 00 00 00 nop
<== NOT EXECUTED
40007728 <_Malloc_Process_deferred_frees>:
return p;
}
void _Malloc_Process_deferred_frees( void )
{
40007728: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000772c: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40007730: 3b 10 00 94 sethi %hi(0x40025000), %i5
40007734: d0 07 60 cc ld [ %i5 + 0xcc ], %o0 ! 400250cc <_Malloc_GC_list>
40007738: ba 17 60 cc or %i5, 0xcc, %i5
if ( !_Chain_Is_empty(the_chain))
4000773c: b8 07 60 04 add %i5, 4, %i4
40007740: 80 a2 00 1c cmp %o0, %i4
40007744: 02 80 00 0e be 4000777c <_Malloc_Process_deferred_frees+0x54>
<== ALWAYS TAKEN
40007748: 01 00 00 00 nop
new_first = old_first->next;
4000774c: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
head->next = new_first;
40007750: c4 27 40 00 st %g2, [ %i5 ]
<== NOT EXECUTED
new_first->previous = head;
40007754: fa 20 a0 04 st %i5, [ %g2 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007758: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000775c: 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 );
40007760: 7f ff fe 88 call 40007180 <free>
<== NOT EXECUTED
40007764: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007768: 91 d0 20 09 ta 9
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4000776c: d0 07 40 00 ld [ %i5 ], %o0
<== NOT EXECUTED
if ( !_Chain_Is_empty(the_chain))
40007770: 80 a2 00 1c cmp %o0, %i4
<== NOT EXECUTED
40007774: 32 bf ff f7 bne,a 40007750 <_Malloc_Process_deferred_frees+0x28>
<== NOT EXECUTED
40007778: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000777c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007780: 01 00 00 00 nop
}
}
40007784: 81 c7 e0 08 ret
40007788: 81 e8 00 00 restore
400076ec <_Malloc_System_state>:
400076ec: 03 10 00 9b sethi %hi(0x40026c00), %g1
400076f0: c2 00 60 7c ld [ %g1 + 0x7c ], %g1 ! 40026c7c <_System_state_Current>
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 ) ) {
400076f4: 84 18 60 01 xor %g1, 1, %g2
return MALLOC_SYSTEM_STATE_NORMAL;
} else {
return MALLOC_SYSTEM_STATE_NO_PROTECTION;
400076f8: 80 a0 00 02 cmp %g0, %g2
400076fc: 90 40 20 00 addx %g0, 0, %o0
if ( _System_state_Is_up( state ) ) {
40007700: 80 a0 60 02 cmp %g1, 2
40007704: 02 80 00 04 be 40007714 <_Malloc_System_state+0x28>
<== ALWAYS TAKEN
40007708: 01 00 00 00 nop
}
}
4000770c: 81 c3 e0 08 retl
<== NOT EXECUTED
40007710: 01 00 00 00 nop
<== NOT EXECUTED
ISR_Level level;
_ISR_Local_disable( level );
#endif
enabled = _Thread_Dispatch_disable_level == 0;
40007714: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
return MALLOC_SYSTEM_STATE_NO_ALLOCATION;
40007718: 80 a0 00 01 cmp %g0, %g1
4000771c: 90 40 20 00 addx %g0, 0, %o0
}
40007720: 81 c3 e0 08 retl
40007724: 91 2a 20 01 sll %o0, 1, %o0
4001589c <__assert_func>:
const char *file,
int line,
const char *func,
const char *failedexpr
)
{
4001589c: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
rtems_assert_context assert_context = {
400158a0: f0 27 bf f0 st %i0, [ %fp + -16 ]
<== NOT EXECUTED
.line = line,
.function = func,
.failed_expression = failedexpr
};
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
400158a4: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
rtems_assert_context assert_context = {
400158a8: f2 27 bf f4 st %i1, [ %fp + -12 ]
<== NOT EXECUTED
printk("assertion \"%s\" failed: file \"%s\", line %d%s%s\n",
400158ac: 02 80 00 0e be 400158e4 <__assert_func+0x48>
<== NOT EXECUTED
400158b0: f4 3f bf f8 std %i2, [ %fp + -8 ]
<== NOT EXECUTED
400158b4: 19 10 00 a8 sethi %hi(0x4002a000), %o4
<== NOT EXECUTED
400158b8: 98 13 22 c0 or %o4, 0x2c0, %o4 ! 4002a2c0 <IMFS_LIMITS_AND_OPTIONS+0x34>
<== NOT EXECUTED
400158bc: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
400158c0: 9a 10 00 1a mov %i2, %o5
<== NOT EXECUTED
400158c4: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
400158c8: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
400158cc: 11 10 00 a8 sethi %hi(0x4002a000), %o0
<== NOT EXECUTED
400158d0: 7f ff c2 29 call 40006174 <printk>
<== NOT EXECUTED
400158d4: 90 12 22 d0 or %o0, 0x2d0, %o0 ! 4002a2d0 <IMFS_LIMITS_AND_OPTIONS+0x44>
<== NOT EXECUTED
400158d8: 92 07 bf f0 add %fp, -16, %o1
<== NOT EXECUTED
400158dc: 7f ff cb 07 call 400084f8 <_Terminate>
<== NOT EXECUTED
400158e0: 90 10 20 07 mov 7, %o0
<== NOT EXECUTED
400158e4: 19 10 00 a7 sethi %hi(0x40029c00), %o4
<== NOT EXECUTED
400158e8: 98 13 22 e8 or %o4, 0x2e8, %o4 ! 40029ee8 <_Thread_queue_Operations_default+0x10c>
<== NOT EXECUTED
400158ec: 10 bf ff f4 b 400158bc <__assert_func+0x20>
<== NOT EXECUTED
400158f0: b4 10 00 0c mov %o4, %i2
<== NOT EXECUTED
4000e47c <_exit>:
extern void FINI_SYMBOL( void );
#endif
void _exit(int status)
{
4000e47c: 9d e3 bf a0 save %sp, -96, %sp
/*
* If the toolset uses init/fini sections, then we need to
* run the global destructors now.
*/
#if defined(FINI_SYMBOL)
FINI_SYMBOL();
4000e480: 40 00 04 72 call 4000f648 <_fini>
4000e484: 01 00 00 00 nop
#endif
rtems_shutdown_executive(status);
4000e488: 7f ff f7 8b call 4000c2b4 <rtems_shutdown_executive>
4000e48c: 90 10 00 18 mov %i0, %o0
4000e490: 01 00 00 00 nop
<== NOT EXECUTED
4000736c <_gettimeofday_r>:
int _gettimeofday_r(
struct _reent *ignored_reentrancy_stuff RTEMS_UNUSED,
struct timeval *tp,
void *__tz
)
{
4000736c: 9d e3 bf a0 save %sp, -96, %sp
if ( !tp )
40007370: 80 a6 60 00 cmp %i1, 0
40007374: 02 80 00 06 be 4000738c <_gettimeofday_r+0x20>
<== NEVER TAKEN
40007378: 90 10 00 19 mov %i1, %o0
4000737c: 40 00 10 d7 call 4000b6d8 <_Timecounter_Microtime>
40007380: b0 10 20 00 clr %i0
struct timezone *tzp = __tz;
return gettimeofday( tp, tzp );
}
40007384: 81 c7 e0 08 ret
40007388: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EFAULT );
4000738c: 40 00 36 cf call 40014ec8 <__errno>
<== NOT EXECUTED
40007390: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40007394: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
40007398: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000739c: 81 c7 e0 08 ret
<== NOT EXECUTED
400073a0: 81 e8 00 00 restore
<== NOT EXECUTED
4002265c <_isatty_r>:
struct _reent *ptr,
int fd
)
{
(void) ptr;
return isatty( fd );
4002265c: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
40022660: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40022664: 40 00 00 4c call 40022794 <isatty>
<== NOT EXECUTED
40022668: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4002267c <_realloc_r>:
void *_realloc_r(
struct _reent *ignored,
void *ptr,
size_t size
)
{
4002267c: 90 10 00 09 mov %o1, %o0
<== NOT EXECUTED
(void) ignored;
return realloc( ptr, size );
40022680: 92 10 00 0a mov %o2, %o1
<== NOT EXECUTED
40022684: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40022688: 7f ff 96 ff call 40008284 <realloc>
<== NOT EXECUTED
4002268c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40003bec <access>:
int access(
const char *path,
int amode
)
{
40003bec: 9d e3 bf 40 save %sp, -192, %sp
struct stat statbuf;
if ( stat(path, &statbuf) )
40003bf0: 92 07 bf a0 add %fp, -96, %o1
40003bf4: 40 00 04 43 call 40004d00 <stat>
40003bf8: 90 10 00 18 mov %i0, %o0
40003bfc: 80 a2 20 00 cmp %o0, 0
40003c00: 12 80 00 17 bne 40003c5c <access+0x70>
<== ALWAYS TAKEN
40003c04: 80 8e 60 04 btst 4, %i1
return -1;
if ( amode & R_OK ) {
40003c08: 02 80 00 06 be 40003c20 <access+0x34>
<== NOT EXECUTED
40003c0c: 80 8e 60 02 btst 2, %i1
<== NOT EXECUTED
if (!( statbuf.st_mode & S_IREAD ))
40003c10: c2 07 bf ac ld [ %fp + -84 ], %g1
<== NOT EXECUTED
40003c14: 80 88 61 00 btst 0x100, %g1
<== NOT EXECUTED
40003c18: 02 80 00 11 be 40003c5c <access+0x70>
<== NOT EXECUTED
40003c1c: 80 8e 60 02 btst 2, %i1
<== NOT EXECUTED
return -1;
}
if ( amode & W_OK ) {
40003c20: 02 80 00 07 be 40003c3c <access+0x50>
<== NOT EXECUTED
40003c24: b0 8e 60 01 andcc %i1, 1, %i0
<== NOT EXECUTED
if ( !( statbuf.st_mode & S_IWRITE ) )
40003c28: c2 07 bf ac ld [ %fp + -84 ], %g1
<== NOT EXECUTED
40003c2c: 80 88 60 80 btst 0x80, %g1
<== NOT EXECUTED
40003c30: 02 80 00 09 be 40003c54 <access+0x68>
<== NOT EXECUTED
40003c34: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
return -1;
}
if ( amode & X_OK ) {
40003c38: b0 8e 60 01 andcc %i1, 1, %i0
<== NOT EXECUTED
40003c3c: 02 80 00 06 be 40003c54 <access+0x68>
<== NOT EXECUTED
40003c40: f2 07 bf ac ld [ %fp + -84 ], %i1
<== NOT EXECUTED
if ( !( statbuf.st_mode & S_IEXEC ) )
40003c44: b3 36 60 06 srl %i1, 6, %i1
<== NOT EXECUTED
40003c48: b2 1e 60 01 xor %i1, 1, %i1
<== NOT EXECUTED
40003c4c: b2 0e 60 01 and %i1, 1, %i1
<== NOT EXECUTED
40003c50: b0 20 00 19 neg %i1, %i0
<== NOT EXECUTED
40003c54: 81 c7 e0 08 ret
<== NOT EXECUTED
40003c58: 81 e8 00 00 restore
<== NOT EXECUTED
return -1;
40003c5c: b0 10 3f ff mov -1, %i0
return -1;
}
return 0;
}
40003c60: 81 c7 e0 08 ret
40003c64: 81 e8 00 00 restore
40011c98 <chroot>:
#include <unistd.h>
#include <rtems/libio_.h>
int chroot( const char *path )
{
40011c98: 9d e3 be e8 save %sp, -280, %sp
/*
* We use the global environment for path evaluation. This makes it possible
* to escape from a chroot environment referencing an unmounted file system.
*/
rtems_filesystem_eval_path_start_with_root_and_current(
40011c9c: 40 00 2c 25 call 4001cd30 <strlen>
40011ca0: 90 10 00 18 mov %i0, %o0
40011ca4: 96 10 20 19 mov 0x19, %o3
40011ca8: 94 10 00 08 mov %o0, %o2
40011cac: 92 10 00 18 mov %i0, %o1
40011cb0: 90 07 bf 68 add %fp, -152, %o0
40011cb4: 1b 10 01 11 sethi %hi(0x40044400), %o5
40011cb8: 9a 13 61 e4 or %o5, 0x1e4, %o5 ! 400445e4 <rtems_global_user_env>
40011cbc: 40 00 06 3c call 400135ac <rtems_filesystem_eval_path_start_with_root_and_current>
40011cc0: 98 03 60 04 add %o5, 4, %o4
rtems_filesystem_location_copy_and_detach(
40011cc4: 92 07 bf 80 add %fp, -128, %o1
40011cc8: 40 00 08 28 call 40013d68 <rtems_filesystem_location_copy_and_detach>
40011ccc: 90 07 bf 50 add %fp, -176, %o0
&rtems_global_user_env.root_directory,
&rtems_global_user_env.current_directory
);
rtems_filesystem_eval_path_extract_currentloc( &ctx, &loc );
new_current_loc = rtems_filesystem_location_transform_to_global( &loc );
40011cd0: 40 00 08 51 call 40013e14 <rtems_filesystem_location_transform_to_global>
40011cd4: 90 07 bf 50 add %fp, -176, %o0
40011cd8: d0 27 bf 4c st %o0, [ %fp + -180 ]
if ( !rtems_filesystem_global_location_is_null( new_current_loc ) ) {
40011cdc: 3b 10 00 87 sethi %hi(0x40021c00), %i5
40011ce0: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
40011ce4: ba 17 63 c4 or %i5, 0x3c4, %i5
40011ce8: 80 a0 40 1d cmp %g1, %i5
40011cec: 02 80 00 3c be 40011ddc <chroot+0x144>
40011cf0: 01 00 00 00 nop
rtems_filesystem_global_location_t *new_root_loc =
40011cf4: 40 00 07 9e call 40013b6c <rtems_filesystem_global_location_obtain>
40011cf8: 90 07 bf 4c add %fp, -180, %o0
const rtems_filesystem_location_info_t *loc
)
{
struct stat st;
st.st_mode = 0;
40011cfc: c0 27 bf ac clr [ %fp + -84 ]
40011d00: b8 10 00 08 mov %o0, %i4
(void) ( *loc->handlers->fstat_h )( loc, &st );
40011d04: c2 02 20 10 ld [ %o0 + 0x10 ], %g1
40011d08: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40011d0c: 9f c0 40 00 call %g1
40011d10: 92 07 bf a0 add %fp, -96, %o1
rtems_filesystem_global_location_obtain( &new_current_loc );
mode_t type = rtems_filesystem_location_type( &new_root_loc->location );
if ( S_ISDIR( type ) ) {
40011d14: 05 00 00 3c sethi %hi(0xf000), %g2
40011d18: c2 07 bf ac ld [ %fp + -84 ], %g1
40011d1c: 82 08 40 02 and %g1, %g2, %g1
40011d20: 05 00 00 10 sethi %hi(0x4000), %g2
40011d24: 80 a0 40 02 cmp %g1, %g2
40011d28: 32 80 00 14 bne,a 40011d78 <chroot+0xe0>
<== NEVER TAKEN
40011d2c: c2 07 20 10 ld [ %i4 + 0x10 ], %g1
<== NOT EXECUTED
sc = rtems_libio_set_private_env();
40011d30: 40 00 04 14 call 40012d80 <rtems_libio_set_private_env>
40011d34: 01 00 00 00 nop
if (sc == RTEMS_SUCCESSFUL) {
40011d38: 80 a2 20 00 cmp %o0, 0
40011d3c: 12 80 00 21 bne 40011dc0 <chroot+0x128>
<== NEVER TAKEN
40011d40: 80 a2 20 0d cmp %o0, 0xd
rtems_filesystem_global_location_assign(
&rtems_filesystem_root,
40011d44: 40 00 03 fa call 40012d2c <rtems_current_user_env_get>
40011d48: b0 10 20 00 clr %i0
rtems_filesystem_global_location_assign(
40011d4c: 92 10 00 1c mov %i4, %o1
40011d50: 40 00 07 db call 40013cbc <rtems_filesystem_global_location_assign>
40011d54: 90 02 20 04 add %o0, 4, %o0
new_root_loc
);
rtems_filesystem_global_location_assign(
&rtems_filesystem_current,
40011d58: 40 00 03 f5 call 40012d2c <rtems_current_user_env_get>
40011d5c: 01 00 00 00 nop
rtems_filesystem_global_location_assign(
40011d60: 40 00 07 d7 call 40013cbc <rtems_filesystem_global_location_assign>
40011d64: d2 07 bf 4c ld [ %fp + -180 ], %o1
}
} else {
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40011d68: 40 00 06 b1 call 4001382c <rtems_filesystem_eval_path_cleanup>
40011d6c: 90 07 bf 68 add %fp, -152, %o0
40011d70: 81 c7 e0 08 ret
40011d74: 81 e8 00 00 restore
if ( !rtems_filesystem_location_is_null( loc ) ) {
40011d78: 80 a0 40 1d cmp %g1, %i5
<== NOT EXECUTED
40011d7c: 22 80 00 07 be,a 40011d98 <chroot+0x100>
<== NOT EXECUTED
40011d80: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
errno = eno;
40011d84: 40 00 2a 9b call 4001c7f0 <__errno>
<== NOT EXECUTED
40011d88: 01 00 00 00 nop
<== NOT EXECUTED
40011d8c: 82 10 20 14 mov 0x14, %g1 ! 14 <_TLS_Alignment+0x13>
<== NOT EXECUTED
40011d90: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_filesystem_global_location_release( new_root_loc, true );
40011d94: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40011d98: 40 00 07 af call 40013c54 <rtems_filesystem_global_location_release>
<== NOT EXECUTED
40011d9c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
40011da0: 40 00 06 a3 call 4001382c <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
40011da4: 90 07 bf 68 add %fp, -152, %o0
<== NOT EXECUTED
if ( rv != 0 ) {
rtems_filesystem_global_location_release( new_current_loc, false );
40011da8: d0 07 bf 4c ld [ %fp + -180 ], %o0
<== NOT EXECUTED
40011dac: 92 10 20 00 clr %o1
40011db0: 40 00 07 a9 call 40013c54 <rtems_filesystem_global_location_release>
40011db4: b0 10 3f ff mov -1, %i0
}
return rv;
}
40011db8: 81 c7 e0 08 ret
40011dbc: 81 e8 00 00 restore
if (sc != RTEMS_UNSATISFIED) {
40011dc0: 22 bf ff f6 be,a 40011d98 <chroot+0x100>
<== NOT EXECUTED
40011dc4: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
errno = ENOMEM;
40011dc8: 40 00 2a 8a call 4001c7f0 <__errno>
<== NOT EXECUTED
40011dcc: 01 00 00 00 nop
<== NOT EXECUTED
40011dd0: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb>
<== NOT EXECUTED
40011dd4: 10 bf ff f0 b 40011d94 <chroot+0xfc>
<== NOT EXECUTED
40011dd8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
40011ddc: 40 00 06 94 call 4001382c <rtems_filesystem_eval_path_cleanup>
40011de0: 90 07 bf 68 add %fp, -152, %o0
rtems_filesystem_global_location_release( new_current_loc, false );
40011de4: 10 bf ff f2 b 40011dac <chroot+0x114>
40011de8: d0 07 bf 4c ld [ %fp + -180 ], %o0
40007000 <close>:
#include <rtems/libio_.h>
int close(
int fd
)
{
40007000: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
unsigned int flags;
int rc;
if ( (uint32_t) fd >= rtems_libio_number_iops ) {
40007004: 03 10 00 8b sethi %hi(0x40022c00), %g1
40007008: c2 00 61 20 ld [ %g1 + 0x120 ], %g1 ! 40022d20 <rtems_libio_number_iops>
4000700c: 80 a6 00 01 cmp %i0, %g1
40007010: 1a 80 00 1b bcc 4000707c <close+0x7c>
40007014: 01 00 00 00 nop
return &rtems_libio_iops[ fd ];
40007018: b7 2e 20 01 sll %i0, 1, %i3
4000701c: b0 06 c0 18 add %i3, %i0, %i0
40007020: 37 10 00 99 sethi %hi(0x40026400), %i3
40007024: b9 2e 20 04 sll %i0, 4, %i4
40007028: b6 16 e2 c0 or %i3, 0x2c0, %i3
4000702c: b8 06 c0 1c add %i3, %i4, %i4
40007030: c4 07 20 08 ld [ %i4 + 8 ], %g2
unsigned int actual;
(void) succ;
(void) fail;
_ISR_Local_disable( level );
actual = *obj;
40007034: 10 80 00 0f b 40007070 <close+0x70>
40007038: ba 10 00 1c mov %i4, %i5
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000703c: 91 d0 20 09 ta 9
<== NOT EXECUTED
40007040: c6 07 60 08 ld [ %i5 + 8 ], %g3
success = ( actual == *expected );
if ( success ) {
40007044: 80 a1 00 03 cmp %g4, %g3
40007048: 12 80 00 03 bne 40007054 <close+0x54>
4000704c: 84 08 ae ff and %g2, 0xeff, %g2
*obj = desired;
40007050: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007054: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007058: 01 00 00 00 nop
desired,
ATOMIC_ORDER_ACQ_REL,
ATOMIC_ORDER_RELAXED
);
if ( success ) {
4000705c: 80 a1 00 03 cmp %g4, %g3
40007060: 02 80 00 0d be 40007094 <close+0x94>
40007064: 80 88 f0 00 btst -4096, %g3
break;
}
if ( ( flags & ~( LIBIO_FLAGS_REFERENCE_INC - 1U ) ) != 0 ) {
40007068: 12 80 00 16 bne 400070c0 <close+0xc0>
<== ALWAYS TAKEN
4000706c: 84 10 00 03 mov %g3, %g2
if ( ( flags & LIBIO_FLAGS_OPEN ) == 0 ) {
40007070: 80 88 a1 00 btst 0x100, %g2
40007074: 12 bf ff f2 bne 4000703c <close+0x3c>
40007078: 88 08 af ff and %g2, 0xfff, %g4
rtems_set_errno_and_return_minus_one( EBADF );
4000707c: 40 00 37 93 call 40014ec8 <__errno>
40007080: b0 10 3f ff mov -1, %i0
40007084: 82 10 20 09 mov 9, %g1
40007088: c2 22 00 00 st %g1, [ %o0 ]
4000708c: 81 c7 e0 08 ret
40007090: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EBUSY );
}
}
rc = (*iop->pathinfo.handlers->close_h)( iop );
40007094: b1 2e 20 04 sll %i0, 4, %i0
40007098: b6 06 c0 18 add %i3, %i0, %i3
4000709c: c2 06 e0 1c ld [ %i3 + 0x1c ], %g1
400070a0: c2 00 60 04 ld [ %g1 + 4 ], %g1
400070a4: 9f c0 40 00 call %g1
400070a8: 90 10 00 1c mov %i4, %o0
400070ac: b0 10 00 08 mov %o0, %i0
rtems_libio_free( iop );
400070b0: 40 00 01 47 call 400075cc <rtems_libio_free>
400070b4: 90 10 00 1c mov %i4, %o0
return rc;
}
400070b8: 81 c7 e0 08 ret
400070bc: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EBUSY );
400070c0: 40 00 37 82 call 40014ec8 <__errno>
400070c4: b0 10 3f ff mov -1, %i0
400070c8: 82 10 20 10 mov 0x10, %g1
400070cc: c2 22 00 00 st %g1, [ %o0 ]
400070d0: 81 c7 e0 08 ret
400070d4: 81 e8 00 00 restore
400050f4 <fchdir>:
/**
* compatible with SVr4, 4.4BSD and X/OPEN - Change Directory
*/
int fchdir( int fd )
{
400050f4: 9d e3 bf 28 save %sp, -216, %sp
int rv = 0;
rtems_libio_t *iop;
struct stat st;
rtems_filesystem_location_info_t loc;
st.st_mode = 0;
400050f8: c0 27 bf ac clr [ %fp + -84 ]
st.st_uid = 0;
st.st_gid = 0;
LIBIO_GET_IOP( fd, iop );
400050fc: 03 10 00 67 sethi %hi(0x40019c00), %g1
st.st_uid = 0;
40005100: c0 37 bf b2 clrh [ %fp + -78 ]
LIBIO_GET_IOP( fd, iop );
40005104: c2 00 63 88 ld [ %g1 + 0x388 ], %g1
40005108: 80 a6 00 01 cmp %i0, %g1
4000510c: 1a 80 00 44 bcc 4000521c <fchdir+0x128>
<== NEVER TAKEN
40005110: c0 37 bf b4 clrh [ %fp + -76 ]
<== NOT EXECUTED
40005114: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
40005118: b0 07 40 18 add %i5, %i0, %i0
<== NOT EXECUTED
4000511c: 3b 10 00 75 sethi %hi(0x4001d400), %i5
<== NOT EXECUTED
40005120: b1 2e 20 04 sll %i0, 4, %i0
<== NOT EXECUTED
40005124: ba 17 60 a0 or %i5, 0xa0, %i5
<== NOT EXECUTED
40005128: b8 06 00 1d add %i0, %i5, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000512c: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40005130: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40005134: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40005138: c6 27 20 08 st %g3, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000513c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005140: 01 00 00 00 nop
40005144: 80 88 a1 00 btst 0x100, %g2
40005148: 02 80 00 3b be 40005234 <fchdir+0x140>
<== NEVER TAKEN
4000514c: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
40005150: b0 06 20 0c add %i0, 0xc, %i0
40005154: ba 06 00 1d add %i0, %i5, %i5
40005158: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
4000515c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40005160: c2 00 40 00 ld [ %g1 ], %g1
40005164: 9f c0 40 00 call %g1
40005168: 01 00 00 00 nop
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, &st );
4000516c: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
40005170: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40005174: 92 07 bf a0 add %fp, -96, %o1
40005178: 9f c0 40 00 call %g1
4000517c: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40005180: b0 92 20 00 orcc %o0, 0, %i0
40005184: 02 80 00 16 be 400051dc <fchdir+0xe8>
<== ALWAYS TAKEN
40005188: d6 17 bf b4 lduh [ %fp + -76 ], %o3
4000518c: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
40005190: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40005194: c2 00 60 04 ld [ %g1 + 4 ], %g1
40005198: 9f c0 40 00 call %g1
4000519c: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400051a0: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
400051a4: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
400051a8: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400051ac: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400051b0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400051b4: 01 00 00 00 nop
}
}
rtems_filesystem_instance_unlock( &iop->pathinfo );
rtems_libio_iop_drop( iop );
if ( rv == 0 ) {
400051b8: 80 a6 20 00 cmp %i0, 0
400051bc: 02 80 00 04 be 400051cc <fchdir+0xd8>
<== ALWAYS TAKEN
400051c0: 01 00 00 00 nop
rv = rtems_filesystem_chdir( &loc );
}
return rv;
}
400051c4: 81 c7 e0 08 ret
<== NOT EXECUTED
400051c8: 81 e8 00 00 restore
<== NOT EXECUTED
rv = rtems_filesystem_chdir( &loc );
400051cc: 40 00 29 58 call 4000f72c <rtems_filesystem_chdir>
400051d0: 90 07 bf 88 add %fp, -120, %o0
}
400051d4: 81 c7 e0 08 ret
400051d8: 91 e8 00 08 restore %g0, %o0, %o0
bool access_ok = rtems_filesystem_check_access(
400051dc: d4 17 bf b2 lduh [ %fp + -78 ], %o2
400051e0: d2 07 bf ac ld [ %fp + -84 ], %o1
400051e4: 40 00 08 05 call 400071f8 <rtems_filesystem_check_access>
400051e8: 90 10 20 01 mov 1, %o0
if ( access_ok ) {
400051ec: 80 a2 20 00 cmp %o0, 0
400051f0: 02 80 00 06 be 40005208 <fchdir+0x114>
<== NEVER TAKEN
400051f4: 92 10 00 1d mov %i5, %o1
rtems_filesystem_location_clone( &loc, &iop->pathinfo );
400051f8: 40 00 29 72 call 4000f7c0 <rtems_filesystem_location_clone>
400051fc: 90 07 bf 88 add %fp, -120, %o0
40005200: 10 bf ff e4 b 40005190 <fchdir+0x9c>
40005204: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
errno = EACCES;
40005208: 40 00 2e 11 call 40010a4c <__errno>
<== NOT EXECUTED
4000520c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005210: 82 10 20 0d mov 0xd, %g1
<== NOT EXECUTED
40005214: 10 bf ff de b 4000518c <fchdir+0x98>
<== NOT EXECUTED
40005218: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
4000521c: 40 00 2e 0c call 40010a4c <__errno>
<== NOT EXECUTED
40005220: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005224: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40005228: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000522c: 81 c7 e0 08 ret
<== NOT EXECUTED
40005230: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005234: 91 d0 20 09 ta 9
<== NOT EXECUTED
40005238: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
4000523c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005240: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005244: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005248: 01 00 00 00 nop
<== NOT EXECUTED
4000524c: 40 00 2e 00 call 40010a4c <__errno>
<== NOT EXECUTED
40005250: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40005254: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40005258: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000525c: 81 c7 e0 08 ret
<== NOT EXECUTED
40005260: 81 e8 00 00 restore
<== NOT EXECUTED
40005398 <fchmod>:
/**
* POSIX 1003.1b 5.6.4 - Change File Modes
*/
int fchmod( int fd, mode_t mode )
{
40005398: 9d e3 bf a0 save %sp, -96, %sp
int rv;
rtems_libio_t *iop;
LIBIO_GET_IOP( fd, iop );
4000539c: 03 10 00 67 sethi %hi(0x40019c00), %g1
400053a0: c2 00 63 88 ld [ %g1 + 0x388 ], %g1 ! 40019f88 <rtems_libio_number_iops>
400053a4: 80 a6 00 01 cmp %i0, %g1
400053a8: 1a 80 00 28 bcc 40005448 <fchmod+0xb0>
<== NEVER TAKEN
400053ac: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
400053b0: b0 07 40 18 add %i5, %i0, %i0
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
400053b4: 3b 10 00 75 sethi %hi(0x4001d400), %i5
<== NOT EXECUTED
400053b8: b1 2e 20 04 sll %i0, 4, %i0
<== NOT EXECUTED
400053bc: ba 17 60 a0 or %i5, 0xa0, %i5
<== NOT EXECUTED
400053c0: b8 06 00 1d add %i0, %i5, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400053c4: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400053c8: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400053cc: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400053d0: c6 27 20 08 st %g3, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400053d4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400053d8: 01 00 00 00 nop
400053dc: 80 88 a1 00 btst 0x100, %g2
400053e0: 02 80 00 20 be 40005460 <fchmod+0xc8>
<== NEVER TAKEN
400053e4: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
400053e8: b0 06 20 0c add %i0, 0xc, %i0
400053ec: ba 06 00 1d add %i0, %i5, %i5
400053f0: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
400053f4: c2 02 20 0c ld [ %o0 + 0xc ], %g1
400053f8: c2 00 40 00 ld [ %g1 ], %g1
400053fc: 9f c0 40 00 call %g1
40005400: 01 00 00 00 nop
rv = rtems_filesystem_chmod( &iop->pathinfo, mode );
40005404: 92 10 00 19 mov %i1, %o1
40005408: 7f ff ff 97 call 40005264 <rtems_filesystem_chmod>
4000540c: 90 10 00 1d mov %i5, %o0
40005410: b0 10 00 08 mov %o0, %i0
40005414: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40005418: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000541c: c2 00 60 04 ld [ %g1 + 4 ], %g1
40005420: 9f c0 40 00 call %g1
40005424: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005428: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4000542c: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
40005430: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005434: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005438: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000543c: 01 00 00 00 nop
rtems_filesystem_instance_unlock( &iop->pathinfo );
rtems_libio_iop_drop( iop );
return rv;
}
40005440: 81 c7 e0 08 ret
40005444: 81 e8 00 00 restore
LIBIO_GET_IOP( fd, iop );
40005448: 40 00 2d 81 call 40010a4c <__errno>
<== NOT EXECUTED
4000544c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005450: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40005454: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005458: 81 c7 e0 08 ret
<== NOT EXECUTED
4000545c: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005460: 91 d0 20 09 ta 9
<== NOT EXECUTED
40005464: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
40005468: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000546c: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005470: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005474: 01 00 00 00 nop
<== NOT EXECUTED
40005478: 40 00 2d 75 call 40010a4c <__errno>
<== NOT EXECUTED
4000547c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40005480: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40005484: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005488: 81 c7 e0 08 ret
<== NOT EXECUTED
4000548c: 81 e8 00 00 restore
<== NOT EXECUTED
400055bc <fchown>:
/**
* POSIX 1003.1b 5.6.5 - Change Owner and Group of a File
*/
int fchown( int fd, uid_t owner, gid_t group )
{
400055bc: 9d e3 bf a0 save %sp, -96, %sp
int rv;
rtems_libio_t *iop;
LIBIO_GET_IOP( fd, iop );
400055c0: 03 10 00 67 sethi %hi(0x40019c00), %g1
400055c4: c2 00 63 88 ld [ %g1 + 0x388 ], %g1 ! 40019f88 <rtems_libio_number_iops>
400055c8: 80 a6 00 01 cmp %i0, %g1
400055cc: 1a 80 00 29 bcc 40005670 <fchown+0xb4>
<== NEVER TAKEN
400055d0: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
400055d4: b0 07 40 18 add %i5, %i0, %i0
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
400055d8: 3b 10 00 75 sethi %hi(0x4001d400), %i5
<== NOT EXECUTED
400055dc: b1 2e 20 04 sll %i0, 4, %i0
<== NOT EXECUTED
400055e0: ba 17 60 a0 or %i5, 0xa0, %i5
<== NOT EXECUTED
400055e4: b8 06 00 1d add %i0, %i5, %i4
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400055e8: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400055ec: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400055f0: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400055f4: c6 27 20 08 st %g3, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400055f8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400055fc: 01 00 00 00 nop
40005600: 80 88 a1 00 btst 0x100, %g2
40005604: 02 80 00 21 be 40005688 <fchown+0xcc>
<== NEVER TAKEN
40005608: 01 00 00 00 nop
rtems_filesystem_instance_lock( &iop->pathinfo );
4000560c: b0 06 20 0c add %i0, 0xc, %i0
40005610: ba 06 00 1d add %i0, %i5, %i5
40005614: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
40005618: c2 02 20 0c ld [ %o0 + 0xc ], %g1
4000561c: c2 00 40 00 ld [ %g1 ], %g1
40005620: 9f c0 40 00 call %g1
40005624: 01 00 00 00 nop
rv = rtems_filesystem_chown( &iop->pathinfo, owner, group );
40005628: 94 10 00 1a mov %i2, %o2
4000562c: 92 10 00 19 mov %i1, %o1
40005630: 7f ff ff 98 call 40005490 <rtems_filesystem_chown>
40005634: 90 10 00 1d mov %i5, %o0
40005638: b0 10 00 08 mov %o0, %i0
4000563c: d0 07 60 14 ld [ %i5 + 0x14 ], %o0
(*mt_entry->ops->unlock_h)( mt_entry );
40005640: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40005644: c2 00 60 04 ld [ %g1 + 4 ], %g1
40005648: 9f c0 40 00 call %g1
4000564c: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005650: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40005654: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
40005658: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000565c: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005660: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005664: 01 00 00 00 nop
rtems_filesystem_instance_unlock( &iop->pathinfo );
rtems_libio_iop_drop( iop );
return rv;
}
40005668: 81 c7 e0 08 ret
4000566c: 81 e8 00 00 restore
LIBIO_GET_IOP( fd, iop );
40005670: 40 00 2c f7 call 40010a4c <__errno>
<== NOT EXECUTED
40005674: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005678: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
4000567c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005680: 81 c7 e0 08 ret
<== NOT EXECUTED
40005684: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005688: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000568c: c4 07 20 08 ld [ %i4 + 8 ], %g2
<== NOT EXECUTED
40005690: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005694: c4 27 20 08 st %g2, [ %i4 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005698: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000569c: 01 00 00 00 nop
<== NOT EXECUTED
400056a0: 40 00 2c eb call 40010a4c <__errno>
<== NOT EXECUTED
400056a4: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
400056a8: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
400056ac: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400056b0: 81 c7 e0 08 ret
<== NOT EXECUTED
400056b4: 81 e8 00 00 restore
<== NOT EXECUTED
4000570c <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
4000570c: 9d e3 bf 98 save %sp, -104, %sp
int ret;
va_list ap;
va_start( ap, cmd );
40005710: 86 07 a0 4c add %fp, 0x4c, %g3
40005714: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
LIBIO_GET_IOP( fd, iop );
40005718: 09 10 00 67 sethi %hi(0x40019c00), %g4
va_start( ap, cmd );
4000571c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40005720: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40005724: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
LIBIO_GET_IOP( fd, iop );
40005728: c2 01 23 88 ld [ %g4 + 0x388 ], %g1
4000572c: 80 a6 00 01 cmp %i0, %g1
40005730: 1a 80 00 df bcc 40005aac <fcntl+0x3a0>
<== NEVER TAKEN
40005734: c6 27 bf fc st %g3, [ %fp + -4 ]
<== NOT EXECUTED
40005738: 83 2e 20 01 sll %i0, 1, %g1
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
4000573c: 39 10 00 75 sethi %hi(0x4001d400), %i4
<== NOT EXECUTED
40005740: a0 00 40 18 add %g1, %i0, %l0
<== NOT EXECUTED
40005744: b8 17 20 a0 or %i4, 0xa0, %i4
<== NOT EXECUTED
40005748: b7 2c 20 04 sll %l0, 4, %i3
<== NOT EXECUTED
4000574c: ba 07 00 1b add %i4, %i3, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005750: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40005754: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40005758: b4 20 b0 00 sub %g2, -4096, %i2
<== NOT EXECUTED
4000575c: f4 27 60 08 st %i2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005760: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005764: 01 00 00 00 nop
40005768: 80 88 a1 00 btst 0x100, %g2
4000576c: 02 80 00 d6 be 40005ac4 <fcntl+0x3b8>
<== NEVER TAKEN
40005770: 80 a6 60 14 cmp %i1, 0x14
switch ( cmd ) {
40005774: 18 80 00 b7 bgu 40005a50 <fcntl+0x344>
<== NEVER TAKEN
40005778: 85 2e 60 02 sll %i1, 2, %g2
4000577c: 03 10 00 15 sethi %hi(0x40005400), %g1
40005780: 82 10 62 b8 or %g1, 0x2b8, %g1 ! 400056b8 <fchown+0xfc>
40005784: c2 00 40 02 ld [ %g1 + %g2 ], %g1
40005788: 81 c0 40 00 jmp %g1
4000578c: 01 00 00 00 nop
errno = ENOTSUP;
40005790: 40 00 2c af call 40010a4c <__errno>
<== NOT EXECUTED
40005794: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40005798: 82 10 20 86 mov 0x86, %g1
<== NOT EXECUTED
4000579c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400057a0: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
400057a4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400057a8: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400057ac: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400057b0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400057b4: 01 00 00 00 nop
ret = vfcntl(fd,cmd,ap);
va_end(ap);
return ret;
}
400057b8: 81 c7 e0 08 ret
400057bc: 81 e8 00 00 restore
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
400057c0: 40 00 02 61 call 40006144 <rtems_libio_fcntl_flags>
<== NOT EXECUTED
400057c4: d0 00 c0 00 ld [ %g3 ], %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400057c8: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val & arg;
400057cc: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400057d0: 84 08 bd fe and %g2, -514, %g2
<== NOT EXECUTED
400057d4: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400057d8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400057dc: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400057e0: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val | arg;
400057e4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
rtems_libio_iop_flags_set( iop, flags & mask );
400057e8: 90 0a 22 01 and %o0, 0x201, %o0
<== NOT EXECUTED
400057ec: 90 10 80 08 or %g2, %o0, %o0
<== NOT EXECUTED
400057f0: d0 27 60 08 st %o0, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400057f4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400057f8: 01 00 00 00 nop
<== NOT EXECUTED
int ret = 0;
400057fc: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
40005800: 83 2c 20 04 sll %l0, 4, %g1
40005804: b8 07 00 01 add %i4, %g1, %i4
40005808: c2 07 20 1c ld [ %i4 + 0x1c ], %g1
4000580c: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
40005810: 92 10 00 19 mov %i1, %o1
40005814: 9f c0 40 00 call %g1
40005818: 90 10 00 1d mov %i5, %o0
if (err) {
4000581c: b8 92 20 00 orcc %o0, 0, %i4
40005820: 02 bf ff e0 be 400057a0 <fcntl+0x94>
<== ALWAYS TAKEN
40005824: 01 00 00 00 nop
errno = err;
40005828: 40 00 2c 89 call 40010a4c <__errno>
<== NOT EXECUTED
4000582c: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40005830: f8 22 00 00 st %i4, [ %o0 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005834: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40005838: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000583c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005840: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005844: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005848: 01 00 00 00 nop
<== NOT EXECUTED
}
4000584c: 81 c7 e0 08 ret
<== NOT EXECUTED
40005850: 81 e8 00 00 restore
<== NOT EXECUTED
fd2 = va_arg( ap, int );
40005854: e6 00 c0 00 ld [ %g3 ], %l3
<== NOT EXECUTED
if ( (uint32_t) fd2 >= rtems_libio_number_iops ) {
40005858: c2 01 23 88 ld [ %g4 + 0x388 ], %g1
<== NOT EXECUTED
4000585c: 80 a4 c0 01 cmp %l3, %g1
<== NOT EXECUTED
40005860: 1a 80 00 a5 bcc 40005af4 <fcntl+0x3e8>
<== NOT EXECUTED
40005864: b5 2c e0 01 sll %l3, 1, %i2
<== NOT EXECUTED
40005868: b4 06 80 13 add %i2, %l3, %i2
<== NOT EXECUTED
4000586c: a3 2e a0 04 sll %i2, 4, %l1
<== NOT EXECUTED
40005870: a4 07 00 11 add %i4, %l1, %l2
<== NOT EXECUTED
if (iop != iop2)
40005874: 80 a7 40 12 cmp %i5, %l2
<== NOT EXECUTED
40005878: 02 bf ff e2 be 40005800 <fcntl+0xf4>
<== NOT EXECUTED
4000587c: b0 10 20 00 clr %i0
<== NOT EXECUTED
40005880: c2 04 a0 08 ld [ %l2 + 8 ], %g1
<== NOT EXECUTED
if ((rtems_libio_iop_flags( iop2 ) & LIBIO_FLAGS_OPEN) != 0) {
40005884: 80 88 61 00 btst 0x100, %g1
<== NOT EXECUTED
40005888: 22 80 00 0a be,a 400058b0 <fcntl+0x1a4>
<== NOT EXECUTED
4000588c: d0 07 60 08 ld [ %i5 + 8 ], %o0
<== NOT EXECUTED
rv = (*iop2->pathinfo.handlers->close_h)( iop2 );
40005890: c2 04 a0 1c ld [ %l2 + 0x1c ], %g1
<== NOT EXECUTED
40005894: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
40005898: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000589c: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
if (rv == 0) {
400058a0: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
400058a4: 12 80 00 5d bne 40005a18 <fcntl+0x30c>
<== NOT EXECUTED
400058a8: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
400058ac: d0 07 60 08 ld [ %i5 + 8 ], %o0
<== NOT EXECUTED
oflag = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
400058b0: 40 00 02 32 call 40006178 <rtems_libio_to_fcntl_flags>
<== NOT EXECUTED
400058b4: 01 00 00 00 nop
<== NOT EXECUTED
rtems_libio_iop_flags_set( iop2, rtems_libio_fcntl_flags( oflag ) );
400058b8: 40 00 02 23 call 40006144 <rtems_libio_fcntl_flags>
<== NOT EXECUTED
400058bc: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400058c0: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val | arg;
400058c4: c4 04 a0 08 ld [ %l2 + 8 ], %g2
<== NOT EXECUTED
400058c8: 90 10 80 08 or %g2, %o0, %o0
<== NOT EXECUTED
400058cc: d0 24 a0 08 st %o0, [ %l2 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400058d0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400058d4: 01 00 00 00 nop
<== NOT EXECUTED
400058d8: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
400058dc: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
400058e0: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
400058e4: 9f c0 40 00 call %g1
<== NOT EXECUTED
400058e8: b5 2e a0 04 sll %i2, 4, %i2
<== NOT EXECUTED
rtems_filesystem_location_clone( &iop2->pathinfo, &iop->pathinfo );
400058ec: 92 06 e0 0c add %i3, 0xc, %o1
<== NOT EXECUTED
400058f0: 90 04 60 0c add %l1, 0xc, %o0
<== NOT EXECUTED
400058f4: 92 07 00 09 add %i4, %o1, %o1
<== NOT EXECUTED
400058f8: 40 00 27 b2 call 4000f7c0 <rtems_filesystem_location_clone>
<== NOT EXECUTED
400058fc: 90 07 00 08 add %i4, %o0, %o0
<== NOT EXECUTED
40005900: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
40005904: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
40005908: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
4000590c: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005910: b4 07 00 1a add %i4, %i2, %i2
<== NOT EXECUTED
rv = (*iop2->pathinfo.handlers->open_h)( iop2, NULL, oflag, 0 );
40005914: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
<== NOT EXECUTED
40005918: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
4000591c: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
40005920: 96 10 20 00 clr %o3
<== NOT EXECUTED
40005924: 92 10 20 00 clr %o1
<== NOT EXECUTED
40005928: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000592c: 90 10 00 12 mov %l2, %o0
<== NOT EXECUTED
if ( rv == 0 ) {
40005930: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
40005934: 22 80 00 38 be,a 40005a14 <fcntl+0x308>
<== NOT EXECUTED
40005938: b0 10 00 13 mov %l3, %i0
<== NOT EXECUTED
if (ret >= 0) {
4000593c: 10 80 00 37 b 40005a18 <fcntl+0x30c>
<== NOT EXECUTED
40005940: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
40005944: d0 07 60 08 ld [ %i5 + 8 ], %o0
<== NOT EXECUTED
oflag = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
40005948: 40 00 02 0c call 40006178 <rtems_libio_to_fcntl_flags>
<== NOT EXECUTED
4000594c: 01 00 00 00 nop
<== NOT EXECUTED
diop = rtems_libio_allocate();
40005950: 40 00 02 1d call 400061c4 <rtems_libio_allocate>
<== NOT EXECUTED
40005954: a2 10 00 08 mov %o0, %l1
<== NOT EXECUTED
if (diop != NULL) {
40005958: b4 92 20 00 orcc %o0, 0, %i2
<== NOT EXECUTED
4000595c: 02 bf ff 91 be 400057a0 <fcntl+0x94>
<== NOT EXECUTED
40005960: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005964: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->lock_h)( mt_entry );
40005968: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
4000596c: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
40005970: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005974: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_location_clone( &diop->pathinfo, &iop->pathinfo );
40005978: 90 06 a0 0c add %i2, 0xc, %o0
<== NOT EXECUTED
4000597c: 92 06 e0 0c add %i3, 0xc, %o1
<== NOT EXECUTED
40005980: 40 00 27 90 call 4000f7c0 <rtems_filesystem_location_clone>
<== NOT EXECUTED
40005984: 92 07 00 09 add %i4, %o1, %o1
<== NOT EXECUTED
40005988: d0 07 60 20 ld [ %i5 + 0x20 ], %o0
<== NOT EXECUTED
(*mt_entry->ops->unlock_h)( mt_entry );
4000598c: c2 02 20 0c ld [ %o0 + 0xc ], %g1
<== NOT EXECUTED
40005990: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
40005994: 9f c0 40 00 call %g1
<== NOT EXECUTED
40005998: 01 00 00 00 nop
<== NOT EXECUTED
rv = (*diop->pathinfo.handlers->open_h)( diop, NULL, oflag, 0 );
4000599c: c2 06 a0 1c ld [ %i2 + 0x1c ], %g1
<== NOT EXECUTED
400059a0: c2 00 40 00 ld [ %g1 ], %g1
<== NOT EXECUTED
400059a4: 96 10 20 00 clr %o3
<== NOT EXECUTED
400059a8: 94 10 00 11 mov %l1, %o2
<== NOT EXECUTED
400059ac: 92 10 20 00 clr %o1
<== NOT EXECUTED
400059b0: 9f c0 40 00 call %g1
<== NOT EXECUTED
400059b4: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
if ( rv == 0 ) {
400059b8: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
400059bc: 02 80 00 32 be 40005a84 <fcntl+0x378>
<== NOT EXECUTED
400059c0: 01 00 00 00 nop
<== NOT EXECUTED
rtems_libio_free( diop );
400059c4: 40 00 02 15 call 40006218 <rtems_libio_free>
<== NOT EXECUTED
400059c8: 90 10 00 1a mov %i2, %o0
<== NOT EXECUTED
if (ret >= 0) {
400059cc: 10 80 00 13 b 40005a18 <fcntl+0x30c>
<== NOT EXECUTED
400059d0: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
if ( va_arg( ap, int ) )
400059d4: f0 00 c0 00 ld [ %g3 ], %i0
400059d8: 80 a6 20 00 cmp %i0, 0
400059dc: 02 80 00 22 be 40005a64 <fcntl+0x358>
<== NEVER TAKEN
400059e0: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400059e4: 91 d0 20 09 ta 9
<== NOT EXECUTED
400059e8: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400059ec: 84 10 a8 00 or %g2, 0x800, %g2
<== NOT EXECUTED
400059f0: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400059f4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400059f8: 01 00 00 00 nop
int ret = 0;
400059fc: 10 bf ff 81 b 40005800 <fcntl+0xf4>
40005a00: b0 10 20 00 clr %i0 ! 0 <PROM_START>
40005a04: d0 07 60 08 ld [ %i5 + 8 ], %o0
ret = rtems_libio_to_fcntl_flags( rtems_libio_iop_flags( iop ) );
40005a08: 40 00 01 dc call 40006178 <rtems_libio_to_fcntl_flags>
40005a0c: 01 00 00 00 nop
40005a10: b0 10 00 08 mov %o0, %i0
if (ret >= 0) {
40005a14: 80 a6 20 00 cmp %i0, 0
40005a18: 16 bf ff 7b bge 40005804 <fcntl+0xf8>
<== ALWAYS TAKEN
40005a1c: 83 2c 20 04 sll %l0, 4, %g1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005a20: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40005a24: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005a28: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005a2c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005a30: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005a34: 01 00 00 00 nop
<== NOT EXECUTED
}
40005a38: 81 c7 e0 08 ret
<== NOT EXECUTED
40005a3c: 81 e8 00 00 restore
<== NOT EXECUTED
40005a40: f0 07 60 08 ld [ %i5 + 8 ], %i0
ret = ((rtems_libio_iop_flags(iop) & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
40005a44: b1 36 20 0b srl %i0, 0xb, %i0
40005a48: 10 bf ff 6e b 40005800 <fcntl+0xf4>
40005a4c: b0 0e 20 01 and %i0, 1, %i0
errno = EINVAL;
40005a50: 40 00 2b ff call 40010a4c <__errno>
<== NOT EXECUTED
40005a54: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005a58: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40005a5c: 10 bf ff 51 b 400057a0 <fcntl+0x94>
<== NOT EXECUTED
40005a60: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005a64: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val & arg;
40005a68: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005a6c: 84 08 b7 ff and %g2, -2049, %g2
<== NOT EXECUTED
40005a70: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005a74: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005a78: 01 00 00 00 nop
<== NOT EXECUTED
int err = (*iop->pathinfo.handlers->fcntl_h)( iop, cmd );
40005a7c: 10 bf ff 62 b 40005804 <fcntl+0xf8>
<== NOT EXECUTED
40005a80: 83 2c 20 04 sll %l0, 4, %g1
<== NOT EXECUTED
rtems_libio_fcntl_flags( oflag )
40005a84: 40 00 01 b0 call 40006144 <rtems_libio_fcntl_flags>
<== NOT EXECUTED
40005a88: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
rv = rtems_libio_iop_to_descriptor( diop );
40005a8c: b0 26 80 1c sub %i2, %i4, %i0
<== NOT EXECUTED
_Atomic_Store_uint(
40005a90: 90 12 21 00 or %o0, 0x100, %o0
<== NOT EXECUTED
40005a94: 83 3e 20 04 sra %i0, 4, %g1
<== NOT EXECUTED
*obj = desired;
40005a98: d0 26 a0 08 st %o0, [ %i2 + 8 ]
<== NOT EXECUTED
40005a9c: 31 2a aa aa sethi %hi(0xaaaaa800), %i0
<== NOT EXECUTED
40005aa0: b0 16 22 ab or %i0, 0x2ab, %i0 ! aaaaaaab <RAM_END+0x6a6aaaab>
<== NOT EXECUTED
40005aa4: 10 bf ff dc b 40005a14 <fcntl+0x308>
<== NOT EXECUTED
40005aa8: b0 58 40 18 smul %g1, %i0, %i0
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
40005aac: 40 00 2b e8 call 40010a4c <__errno>
<== NOT EXECUTED
40005ab0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005ab4: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40005ab8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005abc: 81 c7 e0 08 ret
<== NOT EXECUTED
40005ac0: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005ac4: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40005ac8: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005acc: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005ad0: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005ad4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005ad8: 01 00 00 00 nop
<== NOT EXECUTED
40005adc: 40 00 2b dc call 40010a4c <__errno>
<== NOT EXECUTED
40005ae0: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40005ae4: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40005ae8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005aec: 81 c7 e0 08 ret
<== NOT EXECUTED
40005af0: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
40005af4: 40 00 2b d6 call 40010a4c <__errno>
<== NOT EXECUTED
40005af8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005afc: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40005b00: 10 bf ff 28 b 400057a0 <fcntl+0x94>
<== NOT EXECUTED
40005b04: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005b24 <fdatasync>:
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
40005b24: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
int rv;
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
40005b28: 03 10 00 67 sethi %hi(0x40019c00), %g1
40005b2c: c2 00 63 88 ld [ %g1 + 0x388 ], %g1 ! 40019f88 <rtems_libio_number_iops>
40005b30: 80 a6 00 01 cmp %i0, %g1
40005b34: 1a 80 00 24 bcc 40005bc4 <fdatasync+0xa0>
<== NEVER TAKEN
40005b38: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
40005b3c: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
40005b40: 31 10 00 75 sethi %hi(0x4001d400), %i0
<== NOT EXECUTED
40005b44: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40005b48: b0 16 20 a0 or %i0, 0xa0, %i0
<== NOT EXECUTED
40005b4c: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005b50: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40005b54: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40005b58: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40005b5c: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005b60: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005b64: 01 00 00 00 nop
40005b68: 84 08 a1 04 and %g2, 0x104, %g2
40005b6c: 80 a0 a1 04 cmp %g2, 0x104
40005b70: 12 80 00 0f bne 40005bac <fdatasync+0x88>
<== NEVER TAKEN
40005b74: 01 00 00 00 nop
/*
* Now process the fdatasync().
*/
rv = (*iop->pathinfo.handlers->fdatasync_h)( iop );
40005b78: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40005b7c: c2 00 60 24 ld [ %g1 + 0x24 ], %g1
40005b80: 9f c0 40 00 call %g1
40005b84: 90 10 00 1d mov %i5, %o0
40005b88: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005b8c: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40005b90: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005b94: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005b98: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005b9c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005ba0: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return rv;
}
40005ba4: 81 c7 e0 08 ret
40005ba8: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005bac: 91 d0 20 09 ta 9
<== NOT EXECUTED
40005bb0: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005bb4: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005bb8: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005bbc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005bc0: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
40005bc4: 40 00 2b a2 call 40010a4c <__errno>
<== NOT EXECUTED
40005bc8: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40005bcc: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40005bd0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005bd4: 81 c7 e0 08 ret
<== NOT EXECUTED
40005bd8: 81 e8 00 00 restore
<== NOT EXECUTED
4000b8d8 <fpathconf>:
*/
long fpathconf(
int fd,
int name
)
{
4000b8d8: 9d e3 bf a0 save %sp, -96, %sp
long return_value;
rtems_libio_t *iop;
const rtems_filesystem_limits_and_options_t *the_limits;
LIBIO_GET_IOP( fd, iop );
4000b8dc: 03 10 00 3a sethi %hi(0x4000e800), %g1
4000b8e0: c2 00 63 90 ld [ %g1 + 0x390 ], %g1 ! 4000eb90 <rtems_libio_number_iops>
4000b8e4: 80 a6 00 01 cmp %i0, %g1
4000b8e8: 1a 80 00 43 bcc 4000b9f4 <fpathconf+0x11c>
4000b8ec: bb 2e 20 01 sll %i0, 1, %i5
4000b8f0: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
4000b8f4: 31 10 00 46 sethi %hi(0x40011800), %i0
<== NOT EXECUTED
4000b8f8: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
4000b8fc: b0 16 21 f0 or %i0, 0x1f0, %i0
<== NOT EXECUTED
4000b900: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b904: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
4000b908: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
4000b90c: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
4000b910: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b914: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b918: 01 00 00 00 nop
4000b91c: 80 88 a1 00 btst 0x100, %g2
4000b920: 02 80 00 2f be 4000b9dc <fpathconf+0x104>
<== NEVER TAKEN
4000b924: 80 a6 60 0b cmp %i1, 0xb
/*
* Now process the information request.
*/
the_limits = iop->pathinfo.mt_entry->pathconf_limits_and_options;
4000b928: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
switch ( name ) {
4000b92c: 18 80 00 27 bgu 4000b9c8 <fpathconf+0xf0>
4000b930: c4 00 60 2c ld [ %g1 + 0x2c ], %g2
4000b934: b3 2e 60 02 sll %i1, 2, %i1
4000b938: 03 10 00 2e sethi %hi(0x4000b800), %g1
4000b93c: 82 10 60 a8 or %g1, 0xa8, %g1 ! 4000b8a8 <close+0xd8>
4000b940: c2 00 40 19 ld [ %g1 + %i1 ], %g1
4000b944: 81 c0 40 00 jmp %g1
4000b948: 01 00 00 00 nop
break;
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
4000b94c: f0 00 a0 24 ld [ %g2 + 0x24 ], %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b950: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4000b954: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000b958: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000b95c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b960: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b964: 01 00 00 00 nop
break;
}
rtems_libio_iop_drop( iop );
return return_value;
}
4000b968: 81 c7 e0 08 ret
4000b96c: 81 e8 00 00 restore
break;
4000b970: 10 bf ff f8 b 4000b950 <fpathconf+0x78>
4000b974: f0 00 a0 28 ld [ %g2 + 0x28 ], %i0
break;
4000b978: 10 bf ff f6 b 4000b950 <fpathconf+0x78>
4000b97c: f0 00 80 00 ld [ %g2 ], %i0
break;
4000b980: 10 bf ff f4 b 4000b950 <fpathconf+0x78>
4000b984: f0 00 a0 04 ld [ %g2 + 4 ], %i0
break;
4000b988: 10 bf ff f2 b 4000b950 <fpathconf+0x78>
4000b98c: f0 00 a0 08 ld [ %g2 + 8 ], %i0
break;
4000b990: 10 bf ff f0 b 4000b950 <fpathconf+0x78>
4000b994: f0 00 a0 0c ld [ %g2 + 0xc ], %i0
break;
4000b998: 10 bf ff ee b 4000b950 <fpathconf+0x78>
4000b99c: f0 00 a0 10 ld [ %g2 + 0x10 ], %i0
break;
4000b9a0: 10 bf ff ec b 4000b950 <fpathconf+0x78>
4000b9a4: f0 00 a0 14 ld [ %g2 + 0x14 ], %i0
break;
4000b9a8: 10 bf ff ea b 4000b950 <fpathconf+0x78>
4000b9ac: f0 00 a0 1c ld [ %g2 + 0x1c ], %i0
break;
4000b9b0: 10 bf ff e8 b 4000b950 <fpathconf+0x78>
4000b9b4: f0 00 a0 20 ld [ %g2 + 0x20 ], %i0
break;
4000b9b8: 10 bf ff e6 b 4000b950 <fpathconf+0x78>
4000b9bc: f0 00 a0 2c ld [ %g2 + 0x2c ], %i0
break;
4000b9c0: 10 bf ff e4 b 4000b950 <fpathconf+0x78>
4000b9c4: f0 00 a0 18 ld [ %g2 + 0x18 ], %i0
errno = EINVAL;
4000b9c8: 40 00 07 1e call 4000d640 <__errno>
4000b9cc: b0 10 3f ff mov -1, %i0
4000b9d0: 82 10 20 16 mov 0x16, %g1
break;
4000b9d4: 10 bf ff df b 4000b950 <fpathconf+0x78>
4000b9d8: c2 22 00 00 st %g1, [ %o0 ]
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000b9dc: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000b9e0: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000b9e4: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000b9e8: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000b9ec: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000b9f0: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
4000b9f4: 40 00 07 13 call 4000d640 <__errno>
4000b9f8: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
4000b9fc: 82 10 20 09 mov 9, %g1
4000ba00: c2 22 00 00 st %g1, [ %o0 ]
4000ba04: 81 c7 e0 08 ret
4000ba08: 81 e8 00 00 restore
40007180 <free>:
#include <stdlib.h>
void free(
void *ptr
)
{
40007180: 9d e3 bf a0 save %sp, -96, %sp
if ( !ptr )
40007184: ba 96 20 00 orcc %i0, 0, %i5
40007188: 02 80 00 0d be 400071bc <free+0x3c>
4000718c: 01 00 00 00 nop
return;
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _Malloc_System_state() != MALLOC_SYSTEM_STATE_NORMAL ) {
40007190: 40 00 01 57 call 400076ec <_Malloc_System_state>
40007194: 01 00 00 00 nop
40007198: 80 a2 20 00 cmp %o0, 0
4000719c: 12 80 00 0a bne 400071c4 <free+0x44>
<== NEVER TAKEN
400071a0: 03 10 00 94 sethi %hi(0x40025000), %g1
_Malloc_Deferred_free(ptr);
return;
}
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
400071a4: d0 00 60 7c ld [ %g1 + 0x7c ], %o0 ! 4002507c <RTEMS_Malloc_Heap>
400071a8: 40 00 13 ee call 4000c160 <_Protected_heap_Free>
400071ac: 92 10 00 1d mov %i5, %o1
400071b0: 80 a2 20 00 cmp %o0, 0
400071b4: 02 80 00 06 be 400071cc <free+0x4c>
<== NEVER TAKEN
400071b8: 92 10 00 1d mov %i5, %o1
rtems_fatal( RTEMS_FATAL_SOURCE_INVALID_HEAP_FREE, (rtems_fatal_code) ptr );
}
}
400071bc: 81 c7 e0 08 ret
400071c0: 81 e8 00 00 restore
_Malloc_Deferred_free(ptr);
400071c4: 40 00 01 ac call 40007874 <_Malloc_Deferred_free>
<== NOT EXECUTED
400071c8: 81 e8 00 00 restore
<== NOT EXECUTED
400071cc: 40 00 0c e2 call 4000a554 <_Terminate>
<== NOT EXECUTED
400071d0: 90 10 20 0c mov 0xc, %o0
<== NOT EXECUTED
400071d4: 01 00 00 00 nop
<== NOT EXECUTED
400071d8 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
400071d8: 9d e3 bf a0 save %sp, -96, %sp
int rv;
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
400071dc: 80 a6 60 00 cmp %i1, 0
400071e0: 02 80 00 32 be 400072a8 <fstat+0xd0>
<== NEVER TAKEN
400071e4: 03 10 00 8b sethi %hi(0x40022c00), %g1
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Now process the stat() request.
*/
LIBIO_GET_IOP( fd, iop );
400071e8: c2 00 61 20 ld [ %g1 + 0x120 ], %g1 ! 40022d20 <rtems_libio_number_iops>
400071ec: 80 a6 00 01 cmp %i0, %g1
400071f0: 1a 80 00 28 bcc 40007290 <fstat+0xb8>
<== NEVER TAKEN
400071f4: 91 2e 20 01 sll %i0, 1, %o0
<== NOT EXECUTED
400071f8: 39 10 00 99 sethi %hi(0x40026400), %i4
<== NOT EXECUTED
400071fc: b0 02 00 18 add %o0, %i0, %i0
<== NOT EXECUTED
40007200: b8 17 22 c0 or %i4, 0x2c0, %i4
<== NOT EXECUTED
40007204: b1 2e 20 04 sll %i0, 4, %i0
<== NOT EXECUTED
40007208: ba 06 00 1c add %i0, %i4, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000720c: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40007210: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40007214: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40007218: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000721c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007220: 01 00 00 00 nop
40007224: 80 88 a1 00 btst 0x100, %g2
40007228: 02 80 00 14 be 40007278 <fstat+0xa0>
<== NEVER TAKEN
4000722c: 94 10 20 60 mov 0x60, %o2
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
40007230: 92 10 20 00 clr %o1
40007234: 40 00 39 35 call 40015708 <memset>
40007238: 90 10 00 19 mov %i1, %o0
rv = (*iop->pathinfo.handlers->fstat_h)( &iop->pathinfo, sbuf );
4000723c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40007240: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40007244: 90 06 20 0c add %i0, 0xc, %o0
40007248: 92 10 00 19 mov %i1, %o1
4000724c: 9f c0 40 00 call %g1
40007250: 90 07 00 08 add %i4, %o0, %o0
40007254: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007258: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
4000725c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40007260: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40007264: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007268: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000726c: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return rv;
}
40007270: 81 c7 e0 08 ret
40007274: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007278: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000727c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40007280: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40007284: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007288: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000728c: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
40007290: 40 00 37 0e call 40014ec8 <__errno>
<== NOT EXECUTED
40007294: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40007298: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
4000729c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400072a0: 81 c7 e0 08 ret
<== NOT EXECUTED
400072a4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
400072a8: 40 00 37 08 call 40014ec8 <__errno>
<== NOT EXECUTED
400072ac: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400072b0: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
400072b4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400072b8: 81 c7 e0 08 ret
<== NOT EXECUTED
400072bc: 81 e8 00 00 restore
<== NOT EXECUTED
40005d1c <fsync>:
* POSIX 1003.1b 6.6.1 - Synchronize the State of a File
*/
int fsync(
int fd
)
{
40005d1c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
int rv;
LIBIO_GET_IOP( fd, iop );
40005d20: 03 10 00 67 sethi %hi(0x40019c00), %g1
40005d24: c2 00 63 88 ld [ %g1 + 0x388 ], %g1 ! 40019f88 <rtems_libio_number_iops>
40005d28: 80 a6 00 01 cmp %i0, %g1
40005d2c: 1a 80 00 23 bcc 40005db8 <fsync+0x9c>
<== NEVER TAKEN
40005d30: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
40005d34: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
40005d38: 31 10 00 75 sethi %hi(0x4001d400), %i0
<== NOT EXECUTED
40005d3c: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40005d40: b0 16 20 a0 or %i0, 0xa0, %i0
<== NOT EXECUTED
40005d44: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005d48: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40005d4c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40005d50: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40005d54: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005d58: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005d5c: 01 00 00 00 nop
40005d60: 80 88 a1 00 btst 0x100, %g2
40005d64: 02 80 00 0f be 40005da0 <fsync+0x84>
<== NEVER TAKEN
40005d68: 01 00 00 00 nop
/*
* Now process the fsync().
*/
rv = (*iop->pathinfo.handlers->fsync_h)( iop );
40005d6c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40005d70: c2 00 60 20 ld [ %g1 + 0x20 ], %g1
40005d74: 9f c0 40 00 call %g1
40005d78: 90 10 00 1d mov %i5, %o0
40005d7c: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005d80: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40005d84: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005d88: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005d8c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005d90: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005d94: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return rv;
}
40005d98: 81 c7 e0 08 ret
40005d9c: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40005da0: 91 d0 20 09 ta 9
<== NOT EXECUTED
40005da4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40005da8: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40005dac: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40005db0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40005db4: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
40005db8: 40 00 2b 25 call 40010a4c <__errno>
<== NOT EXECUTED
40005dbc: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40005dc0: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40005dc4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005dc8: 81 c7 e0 08 ret
<== NOT EXECUTED
40005dcc: 81 e8 00 00 restore
<== NOT EXECUTED
400132e8 <ftruncate>:
#include <unistd.h>
#include <rtems/libio_.h>
int ftruncate( int fd, off_t length )
{
400132e8: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
if ( length >= 0 ) {
400132ec: 80 a6 60 00 cmp %i1, 0
400132f0: 06 80 00 39 bl 400133d4 <ftruncate+0xec>
400132f4: 03 10 00 8b sethi %hi(0x40022c00), %g1
rtems_libio_t *iop;
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EINVAL );
400132f8: c2 00 61 20 ld [ %g1 + 0x120 ], %g1 ! 40022d20 <rtems_libio_number_iops>
400132fc: 80 a6 00 01 cmp %i0, %g1
40013300: 1a 80 00 1f bcc 4001337c <ftruncate+0x94>
<== NEVER TAKEN
40013304: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
40013308: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
4001330c: 31 10 00 99 sethi %hi(0x40026400), %i0
<== NOT EXECUTED
40013310: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40013314: b0 16 22 c0 or %i0, 0x2c0, %i0
<== NOT EXECUTED
40013318: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001331c: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40013320: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40013324: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40013328: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001332c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40013330: 01 00 00 00 nop
40013334: 82 08 a1 04 and %g2, 0x104, %g1
40013338: 80 a0 61 04 cmp %g1, 0x104
4001333c: 12 80 00 16 bne 40013394 <ftruncate+0xac>
40013340: 92 10 00 19 mov %i1, %o1
rv = (*iop->pathinfo.handlers->ftruncate_h)( iop, length );
40013344: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40013348: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
4001334c: 94 10 00 1a mov %i2, %o2
40013350: 9f c0 40 00 call %g1
40013354: 90 10 00 1d mov %i5, %o0
40013358: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4001335c: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40013360: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40013364: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40013368: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4001336c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40013370: 01 00 00 00 nop
40013374: 81 c7 e0 08 ret
40013378: 81 e8 00 00 restore
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EINVAL );
4001337c: 40 00 06 d3 call 40014ec8 <__errno>
<== NOT EXECUTED
40013380: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40013384: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40013388: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4001338c: 81 c7 e0 08 ret
<== NOT EXECUTED
40013390: 81 e8 00 00 restore
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40013394: 91 d0 20 09 ta 9
<== NOT EXECUTED
40013398: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
4001339c: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
400133a0: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400133a4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400133a8: 01 00 00 00 nop
400133ac: 84 08 a1 00 and %g2, 0x100, %g2
400133b0: 80 a0 00 02 cmp %g0, %g2
400133b4: b0 10 3f ff mov -1, %i0
400133b8: 40 00 06 c4 call 40014ec8 <__errno>
400133bc: ba 60 20 00 subx %g0, 0, %i5
400133c0: ba 0f 60 0d and %i5, 0xd, %i5
400133c4: ba 07 60 09 add %i5, 9, %i5
400133c8: fa 22 00 00 st %i5, [ %o0 ]
400133cc: 81 c7 e0 08 ret
400133d0: 81 e8 00 00 restore
rtems_libio_iop_drop( iop );
} else {
errno = EINVAL;
400133d4: 40 00 06 bd call 40014ec8 <__errno>
400133d8: b0 10 3f ff mov -1, %i0
400133dc: 82 10 20 16 mov 0x16, %g1
400133e0: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
400133e4: 81 c7 e0 08 ret
400133e8: 81 e8 00 00 restore
400072d4 <getchark>:
#include <rtems.h>
#include <rtems/bspIo.h>
int getchark(void)
{
400072d4: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( BSP_poll_char )
400072d8: 03 10 00 95 sethi %hi(0x40025400), %g1
<== NOT EXECUTED
400072dc: d0 00 62 0c ld [ %g1 + 0x20c ], %o0 ! 4002560c <BSP_poll_char>
<== NOT EXECUTED
400072e0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400072e4: 02 80 00 06 be 400072fc <getchark+0x28>
<== NOT EXECUTED
400072e8: 01 00 00 00 nop
<== NOT EXECUTED
return (*BSP_poll_char)();
400072ec: 9f c2 00 00 call %o0
<== NOT EXECUTED
400072f0: 01 00 00 00 nop
<== NOT EXECUTED
400072f4: 81 c7 e0 08 ret
<== NOT EXECUTED
400072f8: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
return -1;
}
400072fc: 81 c7 e0 08 ret
<== NOT EXECUTED
40007300: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
4002f354 <getdents>:
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
4002f354: 9d e3 bf 40 save %sp, -192, %sp
4002f358: 91 2e 20 01 sll %i0, 1, %o0
st.st_mode = 0;
4002f35c: c0 27 bf ac clr [ %fp + -84 ]
4002f360: b0 02 00 18 add %o0, %i0, %i0
return &rtems_libio_iops[ fd ];
4002f364: 11 10 05 f8 sethi %hi(0x4017e000), %o0
4002f368: b1 2e 20 04 sll %i0, 4, %i0
4002f36c: 90 12 23 c8 or %o0, 0x3c8, %o0
4002f370: ba 06 00 08 add %i0, %o0, %i5
(void) ( *loc->handlers->fstat_h )( loc, &st );
4002f374: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4002f378: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
iop = rtems_libio_iop( dd_fd );
/*
* Make sure we are working on a directory
*/
type = rtems_filesystem_location_type( &iop->pathinfo );
4002f37c: b0 06 20 0c add %i0, 0xc, %i0
4002f380: 92 07 bf a0 add %fp, -96, %o1
4002f384: 9f c0 40 00 call %g1
4002f388: 90 02 00 18 add %o0, %i0, %o0
if ( !S_ISDIR( type ) )
4002f38c: 05 00 00 3c sethi %hi(0xf000), %g2
4002f390: c2 07 bf ac ld [ %fp + -84 ], %g1
4002f394: 82 08 40 02 and %g1, %g2, %g1
4002f398: 05 00 00 10 sethi %hi(0x4000), %g2
4002f39c: 80 a0 40 02 cmp %g1, %g2
4002f3a0: 12 80 00 09 bne 4002f3c4 <getdents+0x70>
<== NEVER TAKEN
4002f3a4: 94 10 00 1a mov %i2, %o2
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
return (*iop->pathinfo.handlers->read_h)( iop, dd_buf, dd_len );
4002f3a8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4002f3ac: c2 00 60 08 ld [ %g1 + 8 ], %g1
4002f3b0: 92 10 00 19 mov %i1, %o1
4002f3b4: 9f c0 40 00 call %g1
4002f3b8: 90 10 00 1d mov %i5, %o0
}
4002f3bc: 81 c7 e0 08 ret
4002f3c0: 91 e8 00 08 restore %g0, %o0, %o0
rtems_set_errno_and_return_minus_one( ENOTDIR );
4002f3c4: 7f ff b7 89 call 4001d1e8 <__errno>
<== NOT EXECUTED
4002f3c8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4002f3cc: 82 10 20 14 mov 0x14, %g1
<== NOT EXECUTED
4002f3d0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4002f3d4: 81 c7 e0 08 ret
<== NOT EXECUTED
4002f3d8: 81 e8 00 00 restore
<== NOT EXECUTED
40007334 <gettimeofday>:
*/
int gettimeofday(
struct timeval *__restrict tp,
void *__restrict __tz RTEMS_UNUSED
)
{
40007334: 9d e3 bf a0 save %sp, -96, %sp
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp )
40007338: 80 a6 20 00 cmp %i0, 0
4000733c: 02 80 00 06 be 40007354 <gettimeofday+0x20>
<== NEVER TAKEN
40007340: 90 10 00 18 mov %i0, %o0
RTEMS_INLINE_ROUTINE void _TOD_Get_timeval(
struct timeval *time
)
{
_Timecounter_Microtime( time );
40007344: 40 00 10 e5 call 4000b6d8 <_Timecounter_Microtime>
40007348: 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;
}
4000734c: 81 c7 e0 08 ret
40007350: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EFAULT );
40007354: 40 00 36 dd call 40014ec8 <__errno>
<== NOT EXECUTED
40007358: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000735c: 82 10 20 0e mov 0xe, %g1
<== NOT EXECUTED
40007360: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40007364: 81 c7 e0 08 ret
<== NOT EXECUTED
40007368: 81 e8 00 00 restore
<== NOT EXECUTED
400073a4 <ioctl>:
int ioctl(
int fd,
ioctl_command_t command,
...
)
{
400073a4: 9d e3 bf 98 save %sp, -104, %sp
rtems_libio_t *iop;
void *buffer;
LIBIO_GET_IOP( fd, iop );
va_start(ap, command);
400073a8: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
LIBIO_GET_IOP( fd, iop );
400073ac: 03 10 00 8b sethi %hi(0x40022c00), %g1
va_start(ap, command);
400073b0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
400073b4: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
LIBIO_GET_IOP( fd, iop );
400073b8: c2 00 61 20 ld [ %g1 + 0x120 ], %g1
400073bc: 80 a6 00 01 cmp %i0, %g1
400073c0: 1a 80 00 27 bcc 4000745c <ioctl+0xb8>
<== NEVER TAKEN
400073c4: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
<== NOT EXECUTED
400073c8: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
400073cc: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
400073d0: 31 10 00 99 sethi %hi(0x40026400), %i0
<== NOT EXECUTED
400073d4: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
400073d8: b0 16 22 c0 or %i0, 0x2c0, %i0
<== NOT EXECUTED
400073dc: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400073e0: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400073e4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400073e8: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400073ec: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400073f0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400073f4: 01 00 00 00 nop
400073f8: 80 88 a1 00 btst 0x100, %g2
400073fc: 02 80 00 12 be 40007444 <ioctl+0xa0>
<== NEVER TAKEN
40007400: 84 07 a0 4c add %fp, 0x4c, %g2
buffer = va_arg(ap, void *);
/*
* Now process the ioctl().
*/
rc = (*iop->pathinfo.handlers->ioctl_h)( iop, command, buffer );
40007404: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40007408: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000740c: d4 07 a0 4c ld [ %fp + 0x4c ], %o2
40007410: 92 10 00 19 mov %i1, %o1
va_start(ap, command);
40007414: c4 27 bf fc st %g2, [ %fp + -4 ]
rc = (*iop->pathinfo.handlers->ioctl_h)( iop, command, buffer );
40007418: 9f c0 40 00 call %g1
4000741c: 90 10 00 1d mov %i5, %o0
40007420: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007424: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40007428: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000742c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40007430: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007434: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007438: 01 00 00 00 nop
va_end( ap );
rtems_libio_iop_drop( iop );
return rc;
}
4000743c: 81 c7 e0 08 ret
40007440: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007444: 91 d0 20 09 ta 9
<== NOT EXECUTED
40007448: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
4000744c: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40007450: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007454: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007458: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP( fd, iop );
4000745c: 40 00 36 9b call 40014ec8 <__errno>
<== NOT EXECUTED
40007460: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40007464: 82 10 20 09 mov 9, %g1
<== NOT EXECUTED
40007468: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000746c: 81 c7 e0 08 ret
<== NOT EXECUTED
40007470: 81 e8 00 00 restore
<== NOT EXECUTED
4000760c <lseek>:
#include <unistd.h>
#include <rtems/libio_.h>
off_t lseek( int fd, off_t offset, int whence )
{
4000760c: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
off_t rv;
LIBIO_GET_IOP( fd, iop );
40007610: 03 10 00 8b sethi %hi(0x40022c00), %g1
40007614: c2 00 61 20 ld [ %g1 + 0x120 ], %g1 ! 40022d20 <rtems_libio_number_iops>
40007618: 80 a6 00 01 cmp %i0, %g1
4000761c: 1a 80 00 26 bcc 400076b4 <lseek+0xa8>
<== NEVER TAKEN
40007620: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
40007624: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
40007628: 31 10 00 99 sethi %hi(0x40026400), %i0
<== NOT EXECUTED
4000762c: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40007630: b0 16 22 c0 or %i0, 0x2c0, %i0
<== NOT EXECUTED
40007634: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007638: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
4000763c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40007640: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40007644: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007648: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000764c: 01 00 00 00 nop
40007650: 80 88 a1 00 btst 0x100, %g2
40007654: 02 80 00 12 be 4000769c <lseek+0x90>
40007658: 96 10 00 1b mov %i3, %o3
rv = (*iop->pathinfo.handlers->lseek_h)( iop, offset, whence );
4000765c: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40007660: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40007664: 92 10 00 19 mov %i1, %o1
40007668: 94 10 00 1a mov %i2, %o2
4000766c: 9f c0 40 00 call %g1
40007670: 90 10 00 1d mov %i5, %o0
40007674: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
40007678: b2 10 00 09 mov %o1, %i1
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000767c: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40007680: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40007684: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40007688: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000768c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007690: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return rv;
}
40007694: 81 c7 e0 08 ret
40007698: 81 e8 00 00 restore
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000769c: 91 d0 20 09 ta 9
<== NOT EXECUTED
400076a0: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400076a4: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400076a8: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400076ac: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400076b0: 01 00 00 00 nop
LIBIO_GET_IOP( fd, iop );
400076b4: 40 00 36 05 call 40014ec8 <__errno>
400076b8: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
400076bc: 82 10 20 09 mov 9, %g1
400076c0: c2 22 00 00 st %g1, [ %o0 ]
400076c4: 81 c7 e0 08 ret
400076c8: 93 e8 3f ff restore %g0, -1, %o1
40007930 <malloc>:
#include "malloc_p.h"
void *malloc(
size_t size
)
{
40007930: 9d e3 bf a0 save %sp, -96, %sp
void *return_this;
/*
* Validate the parameters
*/
if ( !size )
40007934: 80 a6 20 00 cmp %i0, 0
40007938: 02 80 00 0a be 40007960 <malloc+0x30>
<== NEVER TAKEN
4000793c: 90 10 00 18 mov %i0, %o0
return (void *) 0;
return_this = rtems_heap_allocate_aligned_with_boundary( size, 0, 0 );
40007940: 94 10 20 00 clr %o2
40007944: 7f ff ff 92 call 4000778c <rtems_heap_allocate_aligned_with_boundary>
40007948: 92 10 20 00 clr %o1
if ( !return_this ) {
4000794c: b0 92 20 00 orcc %o0, 0, %i0
40007950: 02 80 00 06 be 40007968 <malloc+0x38>
40007954: 01 00 00 00 nop
errno = ENOMEM;
return (void *) 0;
}
return return_this;
}
40007958: 81 c7 e0 08 ret
4000795c: 81 e8 00 00 restore
40007960: 81 c7 e0 08 ret
<== NOT EXECUTED
40007964: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
errno = ENOMEM;
40007968: 40 00 35 58 call 40014ec8 <__errno>
4000796c: 01 00 00 00 nop
40007970: 82 10 20 0c mov 0xc, %g1 ! c <_TLS_Alignment+0xb>
40007974: c2 22 00 00 st %g1, [ %o0 ]
return (void *) 0;
40007978: 81 c7 e0 08 ret
4000797c: 81 e8 00 00 restore
40007aa0 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
40007aa0: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
if (
40007aa4: 80 a6 e0 01 cmp %i3, 1
40007aa8: 18 80 00 b2 bgu 40007d70 <mount+0x2d0>
<== NEVER TAKEN
40007aac: 01 00 00 00 nop
options == RTEMS_FILESYSTEM_READ_ONLY
|| options == RTEMS_FILESYSTEM_READ_WRITE
) {
rtems_filesystem_fsmount_me_t fsmount_me_h =
40007ab0: 40 00 2e 90 call 400134f0 <rtems_filesystem_get_mount_handler>
40007ab4: 90 10 00 1a mov %i2, %o0
rtems_filesystem_get_mount_handler( filesystemtype );
if ( fsmount_me_h != NULL ) {
40007ab8: a2 92 20 00 orcc %o0, 0, %l1
40007abc: 02 80 00 ad be 40007d70 <mount+0x2d0>
<== NEVER TAKEN
40007ac0: 80 a6 60 00 cmp %i1, 0
const char *target = target_or_null != NULL ? target_or_null : "/";
40007ac4: 02 80 00 78 be 40007ca4 <mount+0x204>
40007ac8: 90 10 00 19 mov %i1, %o0
40007acc: 40 00 38 ee call 40015e84 <strlen>
40007ad0: a6 10 00 19 mov %i1, %l3
40007ad4: a4 02 20 01 add %o0, 1, %l2
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
40007ad8: 40 00 38 eb call 40015e84 <strlen>
40007adc: 90 10 00 1a mov %i2, %o0
strlen( source_or_null ) + 1 : 0;
40007ae0: 80 a6 20 00 cmp %i0, 0
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
40007ae4: a8 02 20 01 add %o0, 1, %l4
strlen( source_or_null ) + 1 : 0;
40007ae8: 02 80 00 61 be 40007c6c <mount+0x1cc>
40007aec: ba 02 20 65 add %o0, 0x65, %i5
40007af0: 40 00 38 e5 call 40015e84 <strlen>
40007af4: 90 10 00 18 mov %i0, %o0
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
40007af8: 92 07 40 12 add %i5, %l2, %o1
strlen( source_or_null ) + 1 : 0;
40007afc: a0 02 20 01 add %o0, 1, %l0
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
40007b00: 90 10 20 01 mov 1, %o0
40007b04: 7f ff fd 1a call 40006f6c <calloc>
40007b08: 92 02 40 10 add %o1, %l0, %o1
if ( mt_entry != NULL ) {
40007b0c: ba 92 20 00 orcc %o0, 0, %i5
40007b10: 12 80 00 08 bne 40007b30 <mount+0x90>
<== ALWAYS TAKEN
40007b14: 84 07 60 64 add %i5, 0x64, %g2
if ( rv != 0 ) {
free( mt_entry );
}
} else {
errno = ENOMEM;
40007b18: 40 00 34 ec call 40014ec8 <__errno>
<== NOT EXECUTED
40007b1c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40007b20: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40007b24: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40007b28: 81 c7 e0 08 ret
<== NOT EXECUTED
40007b2c: 81 e8 00 00 restore
<== NOT EXECUTED
memcpy( str, filesystemtype, filesystemtype_size );
40007b30: 92 10 00 1a mov %i2, %o1
40007b34: 94 10 00 14 mov %l4, %o2
40007b38: 40 00 36 b8 call 40015618 <memcpy>
40007b3c: 90 10 00 02 mov %g2, %o0
mt_entry->type = str;
40007b40: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
str += filesystemtype_size;
40007b44: 84 02 00 14 add %o0, %l4, %g2
memcpy( str, source_or_null, source_size );
40007b48: 94 10 00 10 mov %l0, %o2
40007b4c: 92 10 00 18 mov %i0, %o1
40007b50: 40 00 36 b2 call 40015618 <memcpy>
40007b54: 90 10 00 02 mov %g2, %o0
mt_entry->dev = str;
40007b58: d0 27 60 38 st %o0, [ %i5 + 0x38 ]
rtems_filesystem_global_location_t *mt_fs_root =
40007b5c: b4 07 60 40 add %i5, 0x40, %i2
str += source_size;
40007b60: a0 02 00 10 add %o0, %l0, %l0
memcpy( str, target, target_size );
40007b64: 94 10 00 12 mov %l2, %o2
40007b68: 92 10 00 13 mov %l3, %o1
40007b6c: 40 00 36 ab call 40015618 <memcpy>
40007b70: 90 10 00 10 mov %l0, %o0
mt_entry->mounted = true;
40007b74: 82 10 20 01 mov 1, %g1
40007b78: c2 2f 60 28 stb %g1, [ %i5 + 0x28 ]
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
40007b7c: 03 10 00 8c sethi %hi(0x40023000), %g1
40007b80: 82 10 63 f0 or %g1, 0x3f0, %g1 ! 400233f0 <rtems_filesystem_default_pathconf>
mt_entry->target = str;
40007b84: e0 27 60 30 st %l0, [ %i5 + 0x30 ]
void *starting_address,
size_t number_nodes,
size_t node_size
)
{
_Chain_Initialize(
40007b88: 96 10 20 24 mov 0x24, %o3
mt_entry->pathconf_limits_and_options = &rtems_filesystem_default_pathconf;
40007b8c: c2 27 60 2c st %g1, [ %i5 + 0x2c ]
mt_fs_root->reference_count = 1;
40007b90: 82 10 20 01 mov 1, %g1
mt_entry->mt_fs_root = mt_fs_root;
40007b94: f4 27 60 24 st %i2, [ %i5 + 0x24 ]
40007b98: 94 10 20 01 mov 1, %o2
mt_fs_root->reference_count = 1;
40007b9c: c2 27 60 58 st %g1, [ %i5 + 0x58 ]
40007ba0: 92 10 00 1a mov %i2, %o1
mt_fs_root->location.mt_entry = mt_entry;
40007ba4: fa 27 60 54 st %i5, [ %i5 + 0x54 ]
40007ba8: 90 07 60 14 add %i5, 0x14, %o0
40007bac: 40 00 08 0c call 40009bdc <_Chain_Initialize>
40007bb0: b6 0e e0 01 and %i3, 1, %i3
mt_entry->writeable = options == RTEMS_FILESYSTEM_READ_WRITE;
40007bb4: f6 2f 60 29 stb %i3, [ %i5 + 0x29 ]
rv = (*fsmount_me_h)( mt_entry, data );
40007bb8: 92 10 00 1c mov %i4, %o1
40007bbc: 9f c4 40 00 call %l1
40007bc0: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40007bc4: b0 92 20 00 orcc %o0, 0, %i0
40007bc8: 12 80 00 25 bne 40007c5c <mount+0x1bc>
<== NEVER TAKEN
40007bcc: 80 a6 60 00 cmp %i1, 0
if ( target != NULL ) {
40007bd0: 02 80 00 48 be 40007cf0 <mount+0x250>
40007bd4: 94 10 20 1f mov 0x1f, %o2
rtems_filesystem_location_info_t *currentloc =
40007bd8: 92 10 00 19 mov %i1, %o1
40007bdc: 40 00 03 ea call 40008b84 <rtems_filesystem_eval_path_start>
40007be0: 90 07 bf c8 add %fp, -56, %o0
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40007be4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
return (*mt_entry->ops->are_nodes_equal_h)(
40007be8: c4 00 60 0c ld [ %g1 + 0xc ], %g2
40007bec: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
40007bf0: 9f c0 80 00 call %g2
40007bf4: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
if ( !rtems_filesystem_location_is_instance_root( currentloc ) ) {
40007bf8: 80 a2 20 00 cmp %o0, 0
40007bfc: 12 80 00 63 bne 40007d88 <mount+0x2e8>
<== NEVER TAKEN
40007c00: 92 07 bf e0 add %fp, -32, %o1
rtems_filesystem_location_copy_and_detach(
40007c04: 40 00 05 79 call 400091e8 <rtems_filesystem_location_copy_and_detach>
40007c08: 90 07 bf b0 add %fp, -80, %o0
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
40007c0c: 40 00 05 a2 call 40009294 <rtems_filesystem_location_transform_to_global>
40007c10: 90 07 bf b0 add %fp, -80, %o0
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40007c14: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40007c18: c2 00 60 0c ld [ %g1 + 0xc ], %g1
mt_entry->mt_point_node = mt_point_node;
40007c1c: d0 27 60 20 st %o0, [ %i5 + 0x20 ]
mt_point_node = rtems_filesystem_location_transform_to_global( &targetloc );
40007c20: b8 10 00 08 mov %o0, %i4
rv = (*mt_point_node->location.mt_entry->ops->mount_h)( mt_entry );
40007c24: c2 00 60 2c ld [ %g1 + 0x2c ], %g1
40007c28: 9f c0 40 00 call %g1
40007c2c: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40007c30: b0 92 20 00 orcc %o0, 0, %i0
40007c34: 02 80 00 20 be 40007cb4 <mount+0x214>
40007c38: 90 10 00 1c mov %i4, %o0
rtems_filesystem_global_location_release( mt_point_node, true );
40007c3c: 40 00 05 26 call 400090d4 <rtems_filesystem_global_location_release>
40007c40: 92 10 20 01 mov 1, %o1
rtems_filesystem_eval_path_cleanup( &ctx );
40007c44: 40 00 04 1a call 40008cac <rtems_filesystem_eval_path_cleanup>
40007c48: 90 07 bf c8 add %fp, -56, %o0
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40007c4c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40007c50: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40007c54: 9f c0 40 00 call %g1
40007c58: 90 10 00 1d mov %i5, %o0
free( mt_entry );
40007c5c: 7f ff fd 49 call 40007180 <free>
40007c60: 90 10 00 1d mov %i5, %o0
errno = EINVAL;
rv = -1;
}
return rv;
}
40007c64: 81 c7 e0 08 ret
40007c68: 81 e8 00 00 restore
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
40007c6c: 92 07 40 12 add %i5, %l2, %o1
40007c70: 7f ff fc bf call 40006f6c <calloc>
40007c74: 90 10 20 01 mov 1, %o0
if ( mt_entry != NULL ) {
40007c78: ba 92 20 00 orcc %o0, 0, %i5
40007c7c: 02 bf ff a7 be 40007b18 <mount+0x78>
<== NEVER TAKEN
40007c80: 84 07 60 64 add %i5, 0x64, %g2
memcpy( str, filesystemtype, filesystemtype_size );
40007c84: 92 10 00 1a mov %i2, %o1
40007c88: 94 10 00 14 mov %l4, %o2
40007c8c: 90 10 00 02 mov %g2, %o0
40007c90: 40 00 36 62 call 40015618 <memcpy>
40007c94: b4 07 60 40 add %i5, 0x40, %i2
str += filesystemtype_size;
40007c98: a0 02 00 14 add %o0, %l4, %l0
mt_entry->type = str;
40007c9c: 10 bf ff b2 b 40007b64 <mount+0xc4>
40007ca0: d0 27 60 34 st %o0, [ %i5 + 0x34 ]
const char *target = target_or_null != NULL ? target_or_null : "/";
40007ca4: 27 10 00 8a sethi %hi(0x40022800), %l3
40007ca8: a4 10 20 02 mov 2, %l2
40007cac: 10 bf ff 8b b 40007ad8 <mount+0x38>
40007cb0: a6 14 e3 f0 or %l3, 0x3f0, %l3
rtems_libio_lock();
40007cb4: 7f ff fe 1a call 4000751c <rtems_libio_lock>
40007cb8: 01 00 00 00 nop
old_last = tail->previous;
40007cbc: 03 10 00 94 sethi %hi(0x40025000), %g1
40007cc0: 82 10 60 d8 or %g1, 0xd8, %g1 ! 400250d8 <rtems_filesystem_mount_table>
40007cc4: c4 00 60 08 ld [ %g1 + 8 ], %g2
the_node->next = tail;
40007cc8: 86 00 60 04 add %g1, 4, %g3
tail->previous = the_node;
40007ccc: fa 20 60 08 st %i5, [ %g1 + 8 ]
the_node->next = tail;
40007cd0: c6 27 40 00 st %g3, [ %i5 ]
old_last->next = the_node;
40007cd4: fa 20 80 00 st %i5, [ %g2 ]
rtems_libio_unlock();
40007cd8: 7f ff fe 16 call 40007530 <rtems_libio_unlock>
40007cdc: c4 27 60 04 st %g2, [ %i5 + 4 ]
rtems_filesystem_eval_path_cleanup( &ctx );
40007ce0: 40 00 03 f3 call 40008cac <rtems_filesystem_eval_path_cleanup>
40007ce4: 90 07 bf c8 add %fp, -56, %o0
40007ce8: 81 c7 e0 08 ret
40007cec: 81 e8 00 00 restore
rtems_libio_lock();
40007cf0: 7f ff fe 0b call 4000751c <rtems_libio_lock>
40007cf4: 01 00 00 00 nop
return _Chain_Immutable_head( the_chain )->next;
40007cf8: 03 10 00 94 sethi %hi(0x40025000), %g1
if ( rtems_chain_is_empty( &rtems_filesystem_mount_table ) ) {
40007cfc: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2 ! 400250d8 <rtems_filesystem_mount_table>
40007d00: 82 10 60 d8 or %g1, 0xd8, %g1
40007d04: 86 00 60 04 add %g1, 4, %g3
40007d08: 80 a0 80 03 cmp %g2, %g3
40007d0c: 12 80 00 27 bne 40007da8 <mount+0x308>
<== NEVER TAKEN
40007d10: 01 00 00 00 nop
old_last = tail->previous;
40007d14: c6 00 60 08 ld [ %g1 + 8 ], %g3
the_node->next = tail;
40007d18: c4 27 40 00 st %g2, [ %i5 ]
rtems_filesystem_global_location_obtain( &mt_entry->mt_fs_root );
40007d1c: b8 07 60 24 add %i5, 0x24, %i4
tail->previous = the_node;
40007d20: fa 20 60 08 st %i5, [ %g1 + 8 ]
old_last->next = the_node;
40007d24: fa 20 c0 00 st %i5, [ %g3 ]
rtems_libio_unlock();
40007d28: 7f ff fe 02 call 40007530 <rtems_libio_unlock>
40007d2c: c6 27 60 04 st %g3, [ %i5 + 4 ]
rtems_filesystem_global_location_t *new_fs_root =
40007d30: 40 00 04 af call 40008fec <rtems_filesystem_global_location_obtain>
40007d34: 90 10 00 1c mov %i4, %o0
40007d38: b6 10 00 08 mov %o0, %i3
rtems_filesystem_global_location_t *new_fs_current =
40007d3c: 40 00 04 ac call 40008fec <rtems_filesystem_global_location_obtain>
40007d40: 90 10 00 1c mov %i4, %o0
&rtems_filesystem_root,
40007d44: 40 00 00 fa call 4000812c <rtems_current_user_env_get>
40007d48: ba 10 00 08 mov %o0, %i5
rtems_filesystem_global_location_assign(
40007d4c: 92 10 00 1b mov %i3, %o1
40007d50: 40 00 04 fb call 4000913c <rtems_filesystem_global_location_assign>
40007d54: 90 02 20 04 add %o0, 4, %o0
&rtems_filesystem_current,
40007d58: 40 00 00 f5 call 4000812c <rtems_current_user_env_get>
40007d5c: 01 00 00 00 nop
rtems_filesystem_global_location_assign(
40007d60: 40 00 04 f7 call 4000913c <rtems_filesystem_global_location_assign>
40007d64: 92 10 00 1d mov %i5, %o1
40007d68: 81 c7 e0 08 ret
40007d6c: 81 e8 00 00 restore
errno = EINVAL;
40007d70: 40 00 34 56 call 40014ec8 <__errno>
<== NOT EXECUTED
40007d74: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40007d78: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40007d7c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return rv;
40007d80: 81 c7 e0 08 ret
<== NOT EXECUTED
40007d84: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_filesystem_eval_path_error( &ctx, EBUSY );
40007d88: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
40007d8c: 40 00 02 c3 call 40008898 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40007d90: 92 10 20 10 mov 0x10, %o1
<== NOT EXECUTED
rv = -1;
40007d94: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
40007d98: 40 00 03 c5 call 40008cac <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
40007d9c: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40007da0: 10 bf ff ac b 40007c50 <mount+0x1b0>
<== NOT EXECUTED
40007da4: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
errno = EINVAL;
40007da8: 40 00 34 48 call 40014ec8 <__errno>
<== NOT EXECUTED
40007dac: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40007db0: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40007db4: 7f ff fd df call 40007530 <rtems_libio_unlock>
<== NOT EXECUTED
40007db8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
(*mt_entry->ops->fsunmount_me_h)( mt_entry );
40007dbc: 10 bf ff a5 b 40007c50 <mount+0x1b0>
<== NOT EXECUTED
40007dc0: c2 07 60 0c ld [ %i5 + 0xc ], %g1
<== NOT EXECUTED
40006af4 <mount_and_make_target_path>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
40006af4: 9d e3 bf a0 save %sp, -96, %sp
int rv = -1;
if (target != NULL) {
40006af8: 90 96 60 00 orcc %i1, 0, %o0
40006afc: 02 80 00 0b be 40006b28 <mount_and_make_target_path+0x34>
<== NEVER TAKEN
40006b00: 01 00 00 00 nop
rv = rtems_mkdir(target, S_IRWXU | S_IRWXG | S_IRWXO);
40006b04: 40 00 02 eb call 400076b0 <rtems_mkdir>
40006b08: 92 10 21 ff mov 0x1ff, %o1 ! 1ff <SPARC_THREAD_CONTROL_FP_CONTEXT_OFFSET+0xaf>
if (rv == 0) {
40006b0c: 80 a2 20 00 cmp %o0, 0
40006b10: 02 80 00 04 be 40006b20 <mount_and_make_target_path+0x2c>
<== ALWAYS TAKEN
40006b14: 01 00 00 00 nop
} else {
errno = EINVAL;
}
return rv;
}
40006b18: 81 c7 e0 08 ret
<== NOT EXECUTED
40006b1c: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
rv = mount(
40006b20: 40 00 00 08 call 40006b40 <mount>
<== NOT EXECUTED
40006b24: 81 e8 00 00 restore
errno = EINVAL;
40006b28: 40 00 59 b0 call 4001d1e8 <__errno>
<== NOT EXECUTED
40006b2c: 01 00 00 00 nop
<== NOT EXECUTED
40006b30: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
40006b34: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return rv;
40006b38: 10 bf ff f8 b 40006b18 <mount_and_make_target_path+0x24>
<== NOT EXECUTED
40006b3c: 90 10 3f ff mov -1, %o0
<== NOT EXECUTED
40007ec0 <open>:
/**
* POSIX 1003.1 5.3.1 - Open a File
*/
int open( const char *path, int oflag, ... )
{
40007ec0: 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 );
40007ec4: 82 07 a0 50 add %fp, 0x50, %g1
va_start( ap, oflag );
40007ec8: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
40007ecc: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
40007ed0: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
40007ed4: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
iop = rtems_libio_allocate();
40007ed8: 7f ff fd a8 call 40007578 <rtems_libio_allocate>
40007edc: c2 27 bf 64 st %g1, [ %fp + -156 ]
if ( iop != NULL ) {
40007ee0: ba 92 20 00 orcc %o0, 0, %i5
40007ee4: 02 80 00 76 be 400080bc <open+0x1fc>
<== NEVER TAKEN
40007ee8: 82 06 60 01 add %i1, 1, %g1
bool make = (oflag & O_CREAT) == O_CREAT;
40007eec: 86 0e 62 00 and %i1, 0x200, %g3
bool read_access = (rwflag & _FREAD) == _FREAD;
40007ef0: 94 08 60 01 and %g1, 1, %o2
bool exclusive = (oflag & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL);
40007ef4: 84 0e 6a 00 and %i1, 0xa00, %g2
| (read_access ? RTEMS_FS_PERMS_READ : 0)
40007ef8: 94 02 bf ff add %o2, -1, %o2
| (write_access ? RTEMS_FS_PERMS_WRITE : 0)
40007efc: b8 88 60 02 andcc %g1, 2, %i4
| (read_access ? RTEMS_FS_PERMS_READ : 0)
40007f00: 94 0a bf fc and %o2, -4, %o2
| (write_access ? RTEMS_FS_PERMS_WRITE : 0)
40007f04: 02 80 00 03 be 40007f10 <open+0x50>
40007f08: 94 02 a0 1c add %o2, 0x1c, %o2
40007f0c: 94 12 a0 02 or %o2, 2, %o2
| (make ? RTEMS_FS_MAKE : 0)
40007f10: 80 a0 e0 00 cmp %g3, 0
40007f14: 32 80 00 02 bne,a 40007f1c <open+0x5c>
40007f18: 94 12 a0 20 or %o2, 0x20, %o2
| (exclusive ? RTEMS_FS_EXCLUSIVE : 0);
40007f1c: 80 a0 aa 00 cmp %g2, 0xa00
40007f20: 22 80 00 02 be,a 40007f28 <open+0x68>
40007f24: 94 12 a0 40 or %o2, 0x40, %o2
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
40007f28: 92 10 00 18 mov %i0, %o1
40007f2c: 40 00 03 16 call 40008b84 <rtems_filesystem_eval_path_start>
40007f30: 90 07 bf 68 add %fp, -152, %o0
40007f34: f6 07 bf 74 ld [ %fp + -140 ], %i3
if ( rtems_filesystem_eval_path_has_token( &ctx ) ) {
40007f38: 80 a6 e0 00 cmp %i3, 0
40007f3c: 12 80 00 45 bne 40008050 <open+0x190>
40007f40: 80 a7 20 00 cmp %i4, 0
if ( write_access ) {
40007f44: 02 80 00 0e be 40007f7c <open+0xbc>
40007f48: c2 07 bf 90 ld [ %fp + -112 ], %g1
const rtems_filesystem_location_info_t *loc
)
{
struct stat st;
st.st_mode = 0;
40007f4c: c0 27 bf ac clr [ %fp + -84 ]
(void) ( *loc->handlers->fstat_h )( loc, &st );
40007f50: 92 07 bf a0 add %fp, -96, %o1
40007f54: c2 00 60 18 ld [ %g1 + 0x18 ], %g1
40007f58: 9f c0 40 00 call %g1
40007f5c: 90 07 bf 80 add %fp, -128, %o0
if ( S_ISDIR( type ) ) {
40007f60: 05 00 00 3c sethi %hi(0xf000), %g2
40007f64: c2 07 bf ac ld [ %fp + -84 ], %g1
40007f68: 82 08 40 02 and %g1, %g2, %g1
40007f6c: 05 00 00 10 sethi %hi(0x4000), %g2
40007f70: 80 a0 40 02 cmp %g1, %g2
40007f74: 02 80 00 4e be 400080ac <open+0x1ec>
40007f78: 92 10 20 15 mov 0x15, %o1
rtems_filesystem_location_copy_and_detach(
40007f7c: 92 07 bf 80 add %fp, -128, %o1
40007f80: 40 00 04 9a call 400091e8 <rtems_filesystem_location_copy_and_detach>
40007f84: 90 07 60 0c add %i5, 0xc, %o0
rtems_filesystem_eval_path_cleanup( &ctx );
40007f88: 40 00 03 49 call 40008cac <rtems_filesystem_eval_path_cleanup>
40007f8c: 90 07 bf 68 add %fp, -152, %o0
_Atomic_Store_uint(
40007f90: 7f ff fd 6d call 40007544 <rtems_libio_fcntl_flags>
40007f94: 90 10 00 19 mov %i1, %o0
rv = (*iop->pathinfo.handlers->open_h)( iop, path, oflag, mode );
40007f98: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
*obj = desired;
40007f9c: d0 27 60 08 st %o0, [ %i5 + 8 ]
40007fa0: 92 10 00 18 mov %i0, %o1
40007fa4: c2 00 40 00 ld [ %g1 ], %g1
40007fa8: 96 10 00 1a mov %i2, %o3
40007fac: 94 10 00 19 mov %i1, %o2
40007fb0: 9f c0 40 00 call %g1
40007fb4: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40007fb8: b0 92 20 00 orcc %o0, 0, %i0
40007fbc: 12 80 00 13 bne 40008008 <open+0x148>
40007fc0: 80 a6 20 00 cmp %i0, 0
int fd = rtems_libio_iop_to_descriptor( iop );
40007fc4: 31 10 00 99 sethi %hi(0x40026400), %i0
<== NOT EXECUTED
40007fc8: 03 2a aa aa sethi %hi(0xaaaaa800), %g1
<== NOT EXECUTED
40007fcc: b0 16 22 c0 or %i0, 0x2c0, %i0
<== NOT EXECUTED
40007fd0: 82 10 62 ab or %g1, 0x2ab, %g1
<== NOT EXECUTED
40007fd4: b0 27 40 18 sub %i5, %i0, %i0
<== NOT EXECUTED
40007fd8: b1 3e 20 04 sra %i0, 4, %i0
<== NOT EXECUTED
40007fdc: b0 5e 00 01 smul %i0, %g1, %i0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40007fe0: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val | arg;
40007fe4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40007fe8: 84 10 a1 00 or %g2, 0x100, %g2
<== NOT EXECUTED
40007fec: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007ff0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007ff4: 01 00 00 00 nop
if ( truncate ) {
40007ff8: 80 8e 64 00 btst 0x400, %i1
40007ffc: 12 80 00 07 bne 40008018 <open+0x158>
40008000: 92 10 20 00 clr %o1
if ( rv < 0 ) {
40008004: 80 a6 20 00 cmp %i0, 0
40008008: 06 80 00 0e bl 40008040 <open+0x180>
4000800c: 01 00 00 00 nop
}
va_end( ap );
return rv;
}
40008010: 81 c7 e0 08 ret
40008014: 81 e8 00 00 restore
rv = ftruncate( fd, 0 );
40008018: 94 10 20 00 clr %o2
4000801c: 40 00 2c b3 call 400132e8 <ftruncate>
40008020: 90 10 00 18 mov %i0, %o0
if ( rv != 0 ) {
40008024: 80 a2 20 00 cmp %o0, 0
40008028: 02 bf ff f7 be 40008004 <open+0x144>
<== ALWAYS TAKEN
4000802c: 90 10 00 1d mov %i5, %o0
(*iop->pathinfo.handlers->close_h)( iop );
40008030: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
40008034: c2 00 60 04 ld [ %g1 + 4 ], %g1
<== NOT EXECUTED
40008038: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000803c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rtems_libio_free( iop );
40008040: 7f ff fd 63 call 400075cc <rtems_libio_free>
40008044: 90 10 00 1d mov %i5, %o0
40008048: 81 c7 e0 08 ret
4000804c: 81 e8 00 00 restore
40008050: e0 07 bf 70 ld [ %fp + -144 ], %l0
rv = rtems_filesystem_mknod(
40008054: 98 10 20 00 clr %o4
40008058: 9a 10 20 00 clr %o5
4000805c: 17 00 00 20 sethi %hi(0x8000), %o3
40008060: 94 10 00 1b mov %i3, %o2
40008064: 96 16 80 0b or %i2, %o3, %o3
40008068: 92 10 00 10 mov %l0, %o1
4000806c: 7f ff fe 4c call 4000799c <rtems_filesystem_mknod>
40008070: 90 07 bf 80 add %fp, -128, %o0
if ( rv == 0 ) {
40008074: 80 a2 20 00 cmp %o0, 0
40008078: 02 80 00 06 be 40008090 <open+0x1d0>
4000807c: 92 10 20 00 clr %o1
rtems_filesystem_eval_path_error( ctx, 0 );
40008080: 40 00 02 06 call 40008898 <rtems_filesystem_eval_path_error>
40008084: 90 07 bf 68 add %fp, -152, %o0
if ( write_access ) {
40008088: 10 bf ff af b 40007f44 <open+0x84>
4000808c: 80 a7 20 00 cmp %i4, 0
ctx->flags = flags;
40008090: c0 27 bf 78 clr [ %fp + -136 ]
rtems_filesystem_eval_path_continue( ctx );
40008094: 90 07 bf 68 add %fp, -152, %o0
ctx->path = path;
40008098: e0 27 bf 68 st %l0, [ %fp + -152 ]
4000809c: 40 00 02 47 call 400089b8 <rtems_filesystem_eval_path_continue>
400080a0: f6 27 bf 6c st %i3, [ %fp + -148 ]
if ( write_access ) {
400080a4: 10 bf ff a8 b 40007f44 <open+0x84>
400080a8: 80 a7 20 00 cmp %i4, 0
rtems_filesystem_eval_path_error( &ctx, EISDIR );
400080ac: 40 00 01 fb call 40008898 <rtems_filesystem_eval_path_error>
400080b0: 90 07 bf 68 add %fp, -152, %o0
rtems_filesystem_location_copy_and_detach(
400080b4: 10 bf ff b3 b 40007f80 <open+0xc0>
400080b8: 92 07 bf 80 add %fp, -128, %o1
errno = ENFILE;
400080bc: 40 00 33 83 call 40014ec8 <__errno>
<== NOT EXECUTED
400080c0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400080c4: 82 10 20 17 mov 0x17, %g1
<== NOT EXECUTED
400080c8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
400080cc: 81 c7 e0 08 ret
<== NOT EXECUTED
400080d0: 81 e8 00 00 restore
<== NOT EXECUTED
400080d4 <printk>:
/**
* Kernel printf function requiring minimal infrastructure.
*/
int printk(const char *fmt, ...)
{
400080d4: 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 */
400080d8: 82 07 a0 48 add %fp, 0x48, %g1
<== NOT EXECUTED
400080dc: f2 27 a0 48 st %i1, [ %fp + 0x48 ]
<== NOT EXECUTED
len = vprintk(fmt, ap);
400080e0: 92 10 00 01 mov %g1, %o1
<== NOT EXECUTED
va_start(ap, fmt); /* make ap point to 1st unnamed arg */
400080e4: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
<== NOT EXECUTED
len = vprintk(fmt, ap);
400080e8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
va_start(ap, fmt); /* make ap point to 1st unnamed arg */
400080ec: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
<== NOT EXECUTED
400080f0: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
<== NOT EXECUTED
400080f4: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
<== NOT EXECUTED
len = vprintk(fmt, ap);
400080f8: 40 00 05 32 call 400095c0 <vprintk>
<== NOT EXECUTED
400080fc: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
va_end(ap); /* clean up when done */
return len;
}
40008100: 81 c7 e0 08 ret
<== NOT EXECUTED
40008104: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
40008180 <read>:
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
40008180: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
ssize_t n;
rtems_libio_check_buffer( buffer );
40008184: 80 a6 60 00 cmp %i1, 0
40008188: 02 80 00 32 be 40008250 <read+0xd0>
<== NEVER TAKEN
4000818c: 80 a6 a0 00 cmp %i2, 0
rtems_libio_check_count( count );
40008190: 02 80 00 22 be 40008218 <read+0x98>
<== NEVER TAKEN
40008194: 84 10 20 00 clr %g2
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
40008198: 03 10 00 8b sethi %hi(0x40022c00), %g1
4000819c: c2 00 61 20 ld [ %g1 + 0x120 ], %g1 ! 40022d20 <rtems_libio_number_iops>
400081a0: 80 a6 00 01 cmp %i0, %g1
400081a4: 1a 80 00 25 bcc 40008238 <read+0xb8>
400081a8: bb 2e 20 01 sll %i0, 1, %i5
return &rtems_libio_iops[ fd ];
400081ac: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
400081b0: 31 10 00 99 sethi %hi(0x40026400), %i0
<== NOT EXECUTED
400081b4: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
400081b8: b0 16 22 c0 or %i0, 0x2c0, %i0
<== NOT EXECUTED
400081bc: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400081c0: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400081c4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400081c8: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400081cc: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400081d0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400081d4: 01 00 00 00 nop
400081d8: 84 08 a1 02 and %g2, 0x102, %g2
400081dc: 80 a0 a1 02 cmp %g2, 0x102
400081e0: 12 80 00 10 bne 40008220 <read+0xa0>
400081e4: 94 10 00 1a mov %i2, %o2
/*
* Now process the read().
*/
n = (*iop->pathinfo.handlers->read_h)( iop, buffer, count );
400081e8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
400081ec: c2 00 60 08 ld [ %g1 + 8 ], %g1
400081f0: 92 10 00 19 mov %i1, %o1
400081f4: 9f c0 40 00 call %g1
400081f8: 90 10 00 1d mov %i5, %o0
400081fc: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008200: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40008204: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
40008208: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
4000820c: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008210: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008214: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return n;
}
40008218: 81 c7 e0 08 ret
4000821c: 91 e8 00 02 restore %g0, %g2, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008220: 91 d0 20 09 ta 9
<== NOT EXECUTED
40008224: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40008228: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
4000822c: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008230: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008234: 01 00 00 00 nop
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_READ, EBADF );
40008238: 40 00 33 24 call 40014ec8 <__errno>
4000823c: 01 00 00 00 nop
40008240: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
40008244: 84 10 3f ff mov -1, %g2
40008248: 10 bf ff f4 b 40008218 <read+0x98>
4000824c: c2 22 00 00 st %g1, [ %o0 ]
rtems_libio_check_buffer( buffer );
40008250: 40 00 33 1e call 40014ec8 <__errno>
<== NOT EXECUTED
40008254: 01 00 00 00 nop
<== NOT EXECUTED
40008258: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
4000825c: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
40008260: 10 bf ff ee b 40008218 <read+0x98>
<== NOT EXECUTED
40008264: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006eec <readv>:
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
40006eec: 9d e3 bf a0 save %sp, -96, %sp
if ( iov == NULL )
40006ef0: 80 a6 60 00 cmp %i1, 0
40006ef4: 02 80 00 3f be 40006ff0 <readv+0x104>
<== NEVER TAKEN
40006ef8: 80 a6 a0 00 cmp %i2, 0
if ( iovcnt <= 0 )
40006efc: 04 80 00 3d ble 40006ff0 <readv+0x104>
<== NEVER TAKEN
40006f00: 80 a6 a4 00 cmp %i2, 0x400
if ( iovcnt > IOV_MAX )
40006f04: 14 80 00 3b bg 40006ff0 <readv+0x104>
<== NEVER TAKEN
40006f08: bb 2e a0 03 sll %i2, 3, %i5
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
40006f0c: 09 1f ff ff sethi %hi(0x7ffffc00), %g4
40006f10: 82 10 00 19 mov %i1, %g1
40006f14: ba 07 40 19 add %i5, %i1, %i5
total = 0;
40006f18: 96 10 20 00 clr %o3
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
40006f1c: 88 11 23 ff or %g4, 0x3ff, %g4
size_t len = iov[ v ].iov_len;
40006f20: c4 00 60 04 ld [ %g1 + 4 ], %g2
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
40006f24: 86 21 00 0b sub %g4, %o3, %g3
40006f28: 80 a0 80 03 cmp %g2, %g3
40006f2c: 18 80 00 31 bgu 40006ff0 <readv+0x104>
<== NEVER TAKEN
40006f30: 01 00 00 00 nop
if ( iov[ v ].iov_base == NULL && len != 0 ) {
40006f34: c6 00 40 00 ld [ %g1 ], %g3
40006f38: 80 a0 e0 00 cmp %g3, 0
40006f3c: 12 80 00 05 bne 40006f50 <readv+0x64>
<== ALWAYS TAKEN
40006f40: 96 02 c0 02 add %o3, %g2, %o3
40006f44: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40006f48: 12 80 00 2a bne 40006ff0 <readv+0x104>
<== NOT EXECUTED
40006f4c: 01 00 00 00 nop
<== NOT EXECUTED
40006f50: 82 00 60 08 add %g1, 8, %g1
for ( v = 0 ; v < iovcnt ; ++v ) {
40006f54: 80 a7 40 01 cmp %i5, %g1
40006f58: 32 bf ff f3 bne,a 40006f24 <readv+0x38>
<== NEVER TAKEN
40006f5c: c4 00 60 04 ld [ %g1 + 4 ], %g2
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
40006f60: 03 10 00 67 sethi %hi(0x40019c00), %g1
40006f64: c2 00 63 88 ld [ %g1 + 0x388 ], %g1 ! 40019f88 <rtems_libio_number_iops>
40006f68: 80 a6 00 01 cmp %i0, %g1
40006f6c: 1a 80 00 2e bcc 40007024 <readv+0x138>
<== NEVER TAKEN
40006f70: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
40006f74: 03 10 00 75 sethi %hi(0x4001d400), %g1
<== NOT EXECUTED
40006f78: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
40006f7c: 82 10 60 a0 or %g1, 0xa0, %g1
<== NOT EXECUTED
40006f80: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40006f84: ba 07 40 01 add %i5, %g1, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006f88: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40006f8c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
40006f90: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40006f94: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006f98: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006f9c: 01 00 00 00 nop
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
40006fa0: 84 08 a1 02 and %g2, 0x102, %g2
40006fa4: 80 a0 a1 02 cmp %g2, 0x102
40006fa8: 12 80 00 19 bne 4000700c <readv+0x120>
<== NEVER TAKEN
40006fac: 80 a2 e0 00 cmp %o3, 0
if ( total > 0 ) {
40006fb0: 04 80 00 08 ble 40006fd0 <readv+0xe4>
<== NEVER TAKEN
40006fb4: 94 10 00 1a mov %i2, %o2
return ( *iop->pathinfo.handlers->readv_h )( iop, iov, iovcnt, total );
40006fb8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40006fbc: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40006fc0: 92 10 00 19 mov %i1, %o1
40006fc4: 9f c0 40 00 call %g1
40006fc8: 90 10 00 1d mov %i5, %o0
40006fcc: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40006fd0: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40006fd4: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40006fd8: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40006fdc: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40006fe0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40006fe4: 01 00 00 00 nop
iov,
iovcnt,
LIBIO_FLAGS_READ,
readv_adapter
);
}
40006fe8: 81 c7 e0 08 ret
40006fec: 91 e8 00 0b restore %g0, %o3, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
40006ff0: 40 00 26 97 call 40010a4c <__errno>
<== NOT EXECUTED
40006ff4: 01 00 00 00 nop
<== NOT EXECUTED
40006ff8: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
40006ffc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40007000: 96 10 3f ff mov -1, %o3
<== NOT EXECUTED
40007004: 81 c7 e0 08 ret
<== NOT EXECUTED
40007008: 91 e8 00 0b restore %g0, %o3, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000700c: 91 d0 20 09 ta 9
<== NOT EXECUTED
40007010: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40007014: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40007018: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000701c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007020: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
40007024: 40 00 26 8a call 40010a4c <__errno>
<== NOT EXECUTED
40007028: 01 00 00 00 nop
<== NOT EXECUTED
4000702c: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
<== NOT EXECUTED
40007030: 96 10 3f ff mov -1, %o3
<== NOT EXECUTED
40007034: 10 bf ff f4 b 40007004 <readv+0x118>
<== NOT EXECUTED
40007038: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40008284 <realloc>:
return new_ptr;
}
void *realloc( void *ptr, size_t size )
{
40008284: 9d e3 bf 98 save %sp, -104, %sp
Heap_Control *heap;
Heap_Resize_status status;
uintptr_t old_size;
uintptr_t avail_size;
if ( size == 0 ) {
40008288: 80 a6 60 00 cmp %i1, 0
4000828c: 02 80 00 40 be 4000838c <realloc+0x108>
<== NEVER TAKEN
40008290: 80 a6 20 00 cmp %i0, 0
free( ptr );
return NULL;
}
if ( ptr == NULL ) {
40008294: 02 80 00 34 be 40008364 <realloc+0xe0>
40008298: 03 10 00 94 sethi %hi(0x40025000), %g1
return malloc( size );
}
heap = RTEMS_Malloc_Heap;
switch ( _Malloc_System_state() ) {
4000829c: 7f ff fd 14 call 400076ec <_Malloc_System_state>
400082a0: fa 00 60 7c ld [ %g1 + 0x7c ], %i5 ! 4002507c <RTEMS_Malloc_Heap>
400082a4: 80 a2 20 00 cmp %o0, 0
400082a8: 02 80 00 21 be 4000832c <realloc+0xa8>
<== ALWAYS TAKEN
400082ac: 01 00 00 00 nop
400082b0: 80 a2 20 01 cmp %o0, 1
<== NOT EXECUTED
400082b4: 32 80 00 2e bne,a 4000836c <realloc+0xe8>
<== NOT EXECUTED
400082b8: ba 10 20 00 clr %i5
<== NOT EXECUTED
_Malloc_Process_deferred_frees();
status = _Heap_Resize_block( heap, ptr, size, &old_size, &avail_size );
_RTEMS_Unlock_allocator();
break;
case MALLOC_SYSTEM_STATE_NO_PROTECTION:
status = _Heap_Resize_block( heap, ptr, size, &old_size, &avail_size );
400082bc: 98 07 bf fc add %fp, -4, %o4
<== NOT EXECUTED
400082c0: 96 07 bf f8 add %fp, -8, %o3
<== NOT EXECUTED
400082c4: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
400082c8: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
400082cc: 40 00 08 58 call 4000a42c <_Heap_Resize_block>
<== NOT EXECUTED
400082d0: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
400082d4: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
break;
default:
return NULL;
}
switch ( status ) {
400082d8: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
400082dc: 02 80 00 12 be 40008324 <realloc+0xa0>
<== NEVER TAKEN
400082e0: ba 10 00 18 mov %i0, %i5
400082e4: 80 a7 20 01 cmp %i4, 1
400082e8: 12 80 00 23 bne 40008374 <realloc+0xf0>
<== NEVER TAKEN
400082ec: f8 07 bf f8 ld [ %fp + -8 ], %i4
new_ptr = malloc( new_size );
400082f0: 7f ff fd 90 call 40007930 <malloc>
400082f4: 90 10 00 19 mov %i1, %o0
if ( new_ptr == NULL ) {
400082f8: ba 92 20 00 orcc %o0, 0, %i5
400082fc: 02 80 00 0a be 40008324 <realloc+0xa0>
<== NEVER TAKEN
40008300: 80 a7 00 19 cmp %i4, %i1
memcpy( new_ptr, old_ptr, ( new_size < old_size ) ? new_size : old_size );
40008304: 08 80 00 03 bleu 40008310 <realloc+0x8c>
<== ALWAYS TAKEN
40008308: 94 10 00 1c mov %i4, %o2
4000830c: 94 10 00 19 mov %i1, %o2
<== NOT EXECUTED
40008310: 92 10 00 18 mov %i0, %o1
40008314: 40 00 34 c1 call 40015618 <memcpy>
40008318: 90 10 00 1d mov %i5, %o0
free( old_ptr );
4000831c: 7f ff fb 99 call 40007180 <free>
40008320: 90 10 00 18 mov %i0, %o0
return new_alloc( ptr, size, old_size );
default:
errno = EINVAL;
return NULL;
}
}
40008324: 81 c7 e0 08 ret
40008328: 91 e8 00 1d restore %g0, %i5, %o0
_RTEMS_Lock_allocator();
4000832c: 40 00 05 ff call 40009b28 <_RTEMS_Lock_allocator>
40008330: 01 00 00 00 nop
_Malloc_Process_deferred_frees();
40008334: 7f ff fc fd call 40007728 <_Malloc_Process_deferred_frees>
40008338: 01 00 00 00 nop
status = _Heap_Resize_block( heap, ptr, size, &old_size, &avail_size );
4000833c: 98 07 bf fc add %fp, -4, %o4
40008340: 96 07 bf f8 add %fp, -8, %o3
40008344: 94 10 00 19 mov %i1, %o2
40008348: 92 10 00 18 mov %i0, %o1
4000834c: 40 00 08 38 call 4000a42c <_Heap_Resize_block>
40008350: 90 10 00 1d mov %i5, %o0
_RTEMS_Unlock_allocator();
40008354: 40 00 05 fa call 40009b3c <_RTEMS_Unlock_allocator>
40008358: b8 10 00 08 mov %o0, %i4
break;
4000835c: 10 bf ff e0 b 400082dc <realloc+0x58>
40008360: 80 a7 20 00 cmp %i4, 0
return malloc( size );
40008364: 7f ff fd 73 call 40007930 <malloc>
40008368: 91 e8 00 19 restore %g0, %i1, %o0
}
4000836c: 81 c7 e0 08 ret
<== NOT EXECUTED
40008370: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
errno = EINVAL;
40008374: 40 00 32 d5 call 40014ec8 <__errno>
<== NOT EXECUTED
40008378: ba 10 20 00 clr %i5
<== NOT EXECUTED
4000837c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40008380: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40008384: 81 c7 e0 08 ret
<== NOT EXECUTED
40008388: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
free( ptr );
4000838c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40008390: 7f ff fb 7c call 40007180 <free>
<== NOT EXECUTED
40008394: ba 10 20 00 clr %i5
<== NOT EXECUTED
return NULL;
40008398: 30 bf ff e3 b,a 40008324 <realloc+0xa0>
<== NOT EXECUTED
40013128 <rtems_assoc_local_by_remote_bitfield>:
uint32_t rtems_assoc_local_by_remote_bitfield(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
40013128: 9d e3 bf a0 save %sp, -96, %sp
4001312c: b8 10 20 20 mov 0x20, %i4
uint32_t b;
uint32_t local_value = 0;
40013130: b6 10 20 00 clr %i3
for (b = 1; b; b <<= 1) {
40013134: 10 80 00 04 b 40013144 <rtems_assoc_local_by_remote_bitfield+0x1c>
40013138: ba 10 20 01 mov 1, %i5
4001313c: 02 80 00 0c be 4001316c <rtems_assoc_local_by_remote_bitfield+0x44>
40013140: bb 2f 60 01 sll %i5, 1, %i5
if (b & remote_value)
40013144: 80 8e 40 1d btst %i1, %i5
40013148: 22 bf ff fd be,a 4001313c <rtems_assoc_local_by_remote_bitfield+0x14>
4001314c: b8 87 3f ff addcc %i4, -1, %i4
local_value |= rtems_assoc_local_by_remote(ap, b);
40013150: 92 10 00 1d mov %i5, %o1
40013154: 40 00 00 08 call 40013174 <rtems_assoc_local_by_remote>
40013158: 90 10 00 18 mov %i0, %o0
for (b = 1; b; b <<= 1) {
4001315c: bb 2f 60 01 sll %i5, 1, %i5
40013160: b8 87 3f ff addcc %i4, -1, %i4
40013164: 12 bf ff f8 bne 40013144 <rtems_assoc_local_by_remote_bitfield+0x1c>
<== ALWAYS TAKEN
40013168: b6 16 c0 08 or %i3, %o0, %i3
}
return local_value;
}
4001316c: 81 c7 e0 08 ret
40013170: 91 e8 00 1b restore %g0, %i3, %o0
4001319c <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
4001319c: 9d e3 bf a0 save %sp, -96, %sp
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
400131a0: d0 06 00 00 ld [ %i0 ], %o0
{
400131a4: ba 10 00 18 mov %i0, %i5
if (rtems_assoc_is_default(ap))
400131a8: 80 a2 20 00 cmp %o0, 0
400131ac: 02 80 00 16 be 40013204 <rtems_assoc_ptr_by_remote+0x68>
<== NEVER TAKEN
400131b0: b0 10 20 00 clr %i0
400131b4: 13 10 00 8e sethi %hi(0x40023800), %o1
400131b8: 40 00 0a c5 call 40015ccc <strcmp>
400131bc: 92 12 60 40 or %o1, 0x40, %o1 ! 40023840 <IMFS_LIMITS_AND_OPTIONS+0x30>
400131c0: 80 a2 20 00 cmp %o0, 0
400131c4: 22 80 00 12 be,a 4001320c <rtems_assoc_ptr_by_remote+0x70>
<== NEVER TAKEN
400131c8: c4 07 60 0c ld [ %i5 + 0xc ], %g2
<== NOT EXECUTED
default_ap = ap++;
for ( ; ap->name; ap++)
if (ap->remote_value == remote_value)
400131cc: c2 07 60 08 ld [ %i5 + 8 ], %g1
400131d0: 80 a6 40 01 cmp %i1, %g1
400131d4: 32 80 00 08 bne,a 400131f4 <rtems_assoc_ptr_by_remote+0x58>
400131d8: ba 07 60 0c add %i5, 0xc, %i5
for ( ; ap->name; ap++)
400131dc: 81 c7 e0 08 ret
400131e0: 91 e8 00 1d restore %g0, %i5, %o0
if (ap->remote_value == remote_value)
400131e4: 80 a0 40 19 cmp %g1, %i1
400131e8: 22 80 00 07 be,a 40013204 <rtems_assoc_ptr_by_remote+0x68>
400131ec: b0 10 00 1d mov %i5, %i0
for ( ; ap->name; ap++)
400131f0: ba 07 60 0c add %i5, 0xc, %i5
400131f4: c2 07 40 00 ld [ %i5 ], %g1
400131f8: 80 a0 60 00 cmp %g1, 0
400131fc: 32 bf ff fa bne,a 400131e4 <rtems_assoc_ptr_by_remote+0x48>
40013200: c2 07 60 08 ld [ %i5 + 8 ], %g1
40013204: 81 c7 e0 08 ret
40013208: 81 e8 00 00 restore
default_ap = ap++;
4001320c: 82 07 60 0c add %i5, 0xc, %g1
<== NOT EXECUTED
for ( ; ap->name; ap++)
40013210: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
40013214: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40013218: 12 bf ff ed bne 400131cc <rtems_assoc_ptr_by_remote+0x30>
<== NOT EXECUTED
4001321c: ba 10 00 01 mov %g1, %i5
<== NOT EXECUTED
40013220: 81 c7 e0 08 ret
<== NOT EXECUTED
40013224: 81 e8 00 00 restore
<== NOT EXECUTED
40013228 <rtems_cache_aligned_malloc>:
#include <rtems.h>
#include <rtems/malloc.h>
void *rtems_cache_aligned_malloc( size_t nbytes )
{
40013228: 9d e3 bf a0 save %sp, -96, %sp
size_t line_size = rtems_cache_get_maximal_line_size();
4001322c: 40 00 3d 01 call 40022630 <rtems_cache_get_maximal_line_size>
40013230: 01 00 00 00 nop
if ( line_size > 0 ) {
40013234: b2 92 20 00 orcc %o0, 0, %i1
40013238: 02 80 00 05 be 4001324c <rtems_cache_aligned_malloc+0x24>
<== NEVER TAKEN
4001323c: 82 06 3f ff add %i0, -1, %g1
/* Assume that the cache line size is a power of two */
size_t m = line_size - 1;
nbytes = (nbytes + m) & ~m;
40013240: b0 20 00 19 neg %i1, %i0
40013244: 82 00 40 19 add %g1, %i1, %g1
40013248: b0 0e 00 01 and %i0, %g1, %i0
}
return rtems_heap_allocate_aligned_with_boundary( nbytes, line_size, 0 );
4001324c: 7f ff d1 50 call 4000778c <rtems_heap_allocate_aligned_with_boundary>
40013250: 95 e8 20 00 restore %g0, 0, %o2
40013714 <rtems_deviceio_control>:
ioctl_command_t command,
void *buffer,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
40013714: 9d e3 bf 90 save %sp, -112, %sp
rtems_status_code status;
rtems_libio_ioctl_args_t args;
args.iop = iop;
40013718: f0 27 bf f0 st %i0, [ %fp + -16 ]
args.command = command;
args.buffer = buffer;
status = rtems_io_control( major, minor, &args );
4001371c: 94 07 bf f0 add %fp, -16, %o2
args.command = command;
40013720: f2 27 bf f4 st %i1, [ %fp + -12 ]
status = rtems_io_control( major, minor, &args );
40013724: 92 10 00 1c mov %i4, %o1
args.buffer = buffer;
40013728: f4 27 bf f8 st %i2, [ %fp + -8 ]
status = rtems_io_control( major, minor, &args );
4001372c: 40 00 01 dc call 40013e9c <rtems_io_control>
40013730: 90 10 00 1b mov %i3, %o0
if ( status == RTEMS_SUCCESSFUL ) {
40013734: 80 a2 20 00 cmp %o0, 0
40013738: 12 80 00 05 bne 4001374c <rtems_deviceio_control+0x38>
<== NEVER TAKEN
4001373c: 01 00 00 00 nop
return args.ioctl_return;
40013740: f0 07 bf fc ld [ %fp + -4 ], %i0
40013744: 81 c7 e0 08 ret
40013748: 81 e8 00 00 restore
} else {
return rtems_status_code_to_errno(status);
4001374c: 40 00 00 e5 call 40013ae0 <rtems_status_code_to_errno>
<== NOT EXECUTED
40013750: 01 00 00 00 nop
<== NOT EXECUTED
}
}
40013754: 81 c7 e0 08 ret
<== NOT EXECUTED
40013758: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
40013634 <rtems_deviceio_read>:
void *buf,
size_t nbyte,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
40013634: 9d e3 bf 80 save %sp, -128, %sp
rtems_status_code status;
rtems_libio_rw_args_t args;
args.iop = iop;
args.offset = iop->offset;
40013638: c4 1e 00 00 ldd [ %i0 ], %g2
args.buffer = buf;
args.count = nbyte;
args.flags = iop->flags;
4001363c: c2 06 20 08 ld [ %i0 + 8 ], %g1
args.iop = iop;
40013640: f0 27 bf e0 st %i0, [ %fp + -32 ]
args.bytes_moved = 0;
status = rtems_io_read( major, minor, &args );
40013644: 94 07 bf e0 add %fp, -32, %o2
args.offset = iop->offset;
40013648: c4 3f bf e8 std %g2, [ %fp + -24 ]
status = rtems_io_read( major, minor, &args );
4001364c: 92 10 00 1c mov %i4, %o1
args.buffer = buf;
40013650: f2 27 bf f0 st %i1, [ %fp + -16 ]
status = rtems_io_read( major, minor, &args );
40013654: 90 10 00 1b mov %i3, %o0
args.count = nbyte;
40013658: f4 27 bf f4 st %i2, [ %fp + -12 ]
{
4001365c: ba 10 00 18 mov %i0, %i5
args.flags = iop->flags;
40013660: c2 27 bf f8 st %g1, [ %fp + -8 ]
status = rtems_io_read( major, minor, &args );
40013664: 40 00 02 55 call 40013fb8 <rtems_io_read>
40013668: c0 27 bf fc clr [ %fp + -4 ]
if ( status == RTEMS_SUCCESSFUL ) {
4001366c: 80 a2 20 00 cmp %o0, 0
40013670: 12 80 00 09 bne 40013694 <rtems_deviceio_read+0x60>
<== NEVER TAKEN
40013674: 01 00 00 00 nop
iop->offset += args.bytes_moved;
40013678: f4 1f 40 00 ldd [ %i5 ], %i2
4001367c: f0 07 bf fc ld [ %fp + -4 ], %i0
40013680: 86 86 c0 18 addcc %i3, %i0, %g3
40013684: 84 46 a0 00 addx %i2, 0, %g2
40013688: c4 3f 40 00 std %g2, [ %i5 ]
return (ssize_t) args.bytes_moved;
4001368c: 81 c7 e0 08 ret
40013690: 81 e8 00 00 restore
} else {
return rtems_status_code_to_errno( status );
40013694: 40 00 01 13 call 40013ae0 <rtems_status_code_to_errno>
<== NOT EXECUTED
40013698: 01 00 00 00 nop
<== NOT EXECUTED
}
}
4001369c: 81 c7 e0 08 ret
<== NOT EXECUTED
400136a0: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
400136a4 <rtems_deviceio_write>:
const void *buf,
size_t nbyte,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
400136a4: 9d e3 bf 80 save %sp, -128, %sp
rtems_status_code status;
rtems_libio_rw_args_t args;
args.iop = iop;
args.offset = iop->offset;
400136a8: c4 1e 00 00 ldd [ %i0 ], %g2
args.buffer = RTEMS_DECONST( void *, buf );
args.count = nbyte;
args.flags = iop->flags;
400136ac: c2 06 20 08 ld [ %i0 + 8 ], %g1
args.iop = iop;
400136b0: f0 27 bf e0 st %i0, [ %fp + -32 ]
args.bytes_moved = 0;
status = rtems_io_write( major, minor, &args );
400136b4: 94 07 bf e0 add %fp, -32, %o2
args.offset = iop->offset;
400136b8: c4 3f bf e8 std %g2, [ %fp + -24 ]
status = rtems_io_write( major, minor, &args );
400136bc: 92 10 00 1c mov %i4, %o1
args.buffer = RTEMS_DECONST( void *, buf );
400136c0: f2 27 bf f0 st %i1, [ %fp + -16 ]
status = rtems_io_write( major, minor, &args );
400136c4: 90 10 00 1b mov %i3, %o0
args.count = nbyte;
400136c8: f4 27 bf f4 st %i2, [ %fp + -12 ]
{
400136cc: ba 10 00 18 mov %i0, %i5
args.flags = iop->flags;
400136d0: c2 27 bf f8 st %g1, [ %fp + -8 ]
status = rtems_io_write( major, minor, &args );
400136d4: 40 00 02 51 call 40014018 <rtems_io_write>
400136d8: c0 27 bf fc clr [ %fp + -4 ]
if ( status == RTEMS_SUCCESSFUL ) {
400136dc: 80 a2 20 00 cmp %o0, 0
400136e0: 12 80 00 09 bne 40013704 <rtems_deviceio_write+0x60>
<== NEVER TAKEN
400136e4: 01 00 00 00 nop
iop->offset += args.bytes_moved;
400136e8: f4 1f 40 00 ldd [ %i5 ], %i2
400136ec: f0 07 bf fc ld [ %fp + -4 ], %i0
400136f0: 86 86 c0 18 addcc %i3, %i0, %g3
400136f4: 84 46 a0 00 addx %i2, 0, %g2
400136f8: c4 3f 40 00 std %g2, [ %i5 ]
return (ssize_t) args.bytes_moved;
400136fc: 81 c7 e0 08 ret
40013700: 81 e8 00 00 restore
} else {
return rtems_status_code_to_errno( status );
40013704: 40 00 00 f7 call 40013ae0 <rtems_status_code_to_errno>
<== NOT EXECUTED
40013708: 01 00 00 00 nop
<== NOT EXECUTED
}
}
4001370c: 81 c7 e0 08 ret
<== NOT EXECUTED
40013710: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
40008558 <rtems_filesystem_check_access>:
int flags,
mode_t object_mode,
uid_t object_uid,
gid_t object_gid
)
{
40008558: 9d e3 bf a0 save %sp, -96, %sp
const rtems_user_env_t *uenv = rtems_current_user_env_get();
4000855c: 7f ff fe f4 call 4000812c <rtems_current_user_env_get>
40008560: 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) {
40008564: c2 12 20 10 lduh [ %o0 + 0x10 ], %g1
40008568: 80 a0 60 00 cmp %g1, 0
4000856c: 02 80 00 24 be 400085fc <rtems_filesystem_check_access+0xa4>
40008570: 80 a0 40 1a cmp %g1, %i2
40008574: 22 80 00 23 be,a 40008600 <rtems_filesystem_check_access+0xa8>
40008578: b1 2e 20 06 sll %i0, 6, %i0
access_flags <<= RTEMS_FS_USR_SHIFT;
} else {
gid_t task_gid = uenv->egid;
if (
task_gid == 0
4000857c: c2 12 20 12 lduh [ %o0 + 0x12 ], %g1
if (
40008580: 80 a0 60 00 cmp %g1, 0
40008584: 02 80 00 18 be 400085e4 <rtems_filesystem_check_access+0x8c>
40008588: 80 a0 40 1b cmp %g1, %i3
4000858c: 22 80 00 17 be,a 400085e8 <rtems_filesystem_check_access+0x90>
40008590: b1 2e 20 03 sll %i0, 3, %i0
for (i = 0; i < uenv->ngroups; ++i) {
40008594: c6 02 20 24 ld [ %o0 + 0x24 ], %g3
40008598: 80 a0 e0 00 cmp %g3, 0
4000859c: 22 80 00 14 be,a 400085ec <rtems_filesystem_check_access+0x94>
400085a0: b0 2e 00 19 andn %i0, %i1, %i0
if (uenv->groups[i] == object_gid) {
400085a4: c2 12 20 28 lduh [ %o0 + 0x28 ], %g1
400085a8: 80 a0 40 1b cmp %g1, %i3
400085ac: 02 80 00 0e be 400085e4 <rtems_filesystem_check_access+0x8c>
400085b0: 90 02 20 2a add %o0, 0x2a, %o0
for (i = 0; i < uenv->ngroups; ++i) {
400085b4: 10 80 00 06 b 400085cc <rtems_filesystem_check_access+0x74>
400085b8: 82 10 20 00 clr %g1
if (uenv->groups[i] == object_gid) {
400085bc: c4 12 3f fe lduh [ %o0 + -2 ], %g2
<== NOT EXECUTED
400085c0: 80 a0 80 1b cmp %g2, %i3
<== NOT EXECUTED
400085c4: 22 80 00 09 be,a 400085e8 <rtems_filesystem_check_access+0x90>
<== NOT EXECUTED
400085c8: b1 2e 20 03 sll %i0, 3, %i0
<== NOT EXECUTED
for (i = 0; i < uenv->ngroups; ++i) {
400085cc: 82 00 60 01 inc %g1
400085d0: 80 a0 40 03 cmp %g1, %g3
400085d4: 12 bf ff fa bne 400085bc <rtems_filesystem_check_access+0x64>
<== NEVER TAKEN
400085d8: 90 02 20 02 add %o0, 2, %o0
} else {
access_flags <<= RTEMS_FS_OTH_SHIFT;
}
}
return (access_flags & object_mode) == access_flags;
400085dc: 10 80 00 04 b 400085ec <rtems_filesystem_check_access+0x94>
400085e0: b0 2e 00 19 andn %i0, %i1, %i0
access_flags <<= RTEMS_FS_GRP_SHIFT;
400085e4: b1 2e 20 03 sll %i0, 3, %i0
return (access_flags & object_mode) == access_flags;
400085e8: b0 2e 00 19 andn %i0, %i1, %i0
}
400085ec: 80 a0 00 18 cmp %g0, %i0
400085f0: b0 60 3f ff subx %g0, -1, %i0
400085f4: 81 c7 e0 08 ret
400085f8: 81 e8 00 00 restore
access_flags <<= RTEMS_FS_USR_SHIFT;
400085fc: b1 2e 20 06 sll %i0, 6, %i0
return (access_flags & object_mode) == access_flags;
40008600: b0 2e 00 19 andn %i0, %i1, %i0
}
40008604: 80 a0 00 18 cmp %g0, %i0
40008608: b0 60 3f ff subx %g0, -1, %i0
4000860c: 81 c7 e0 08 ret
40008610: 81 e8 00 00 restore
40005264 <rtems_filesystem_chmod>:
int rtems_filesystem_chmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
40005264: 9d e3 bf 40 save %sp, -192, %sp
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40005268: f8 06 20 14 ld [ %i0 + 0x14 ], %i4
int rv;
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
4000526c: c2 0f 20 29 ldub [ %i4 + 0x29 ], %g1
{
40005270: ba 10 00 18 mov %i0, %i5
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
40005274: 80 a0 60 00 cmp %g1, 0
40005278: 12 80 00 07 bne 40005294 <rtems_filesystem_chmod+0x30>
4000527c: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
40005280: 03 10 00 69 sethi %hi(0x4001a400), %g1
40005284: 82 10 60 a0 or %g1, 0xa0, %g1 ! 4001a4a0 <rtems_filesystem_null_handlers>
40005288: 80 a0 80 01 cmp %g2, %g1
4000528c: 12 80 00 3d bne 40005380 <rtems_filesystem_chmod+0x11c>
40005290: 01 00 00 00 nop
struct stat st;
memset( &st, 0, sizeof(st) );
40005294: c0 27 bf a0 clr [ %fp + -96 ]
rv = (*loc->handlers->fstat_h)( loc, &st );
40005298: 92 07 bf a0 add %fp, -96, %o1
memset( &st, 0, sizeof(st) );
4000529c: c0 27 bf a4 clr [ %fp + -92 ]
400052a0: c0 27 bf a8 clr [ %fp + -88 ]
400052a4: c0 27 bf ac clr [ %fp + -84 ]
400052a8: c0 27 bf b0 clr [ %fp + -80 ]
400052ac: c0 27 bf b4 clr [ %fp + -76 ]
400052b0: c0 27 bf b8 clr [ %fp + -72 ]
400052b4: c0 27 bf bc clr [ %fp + -68 ]
400052b8: c0 27 bf c0 clr [ %fp + -64 ]
400052bc: c0 27 bf c4 clr [ %fp + -60 ]
400052c0: c0 27 bf c8 clr [ %fp + -56 ]
400052c4: c0 27 bf cc clr [ %fp + -52 ]
400052c8: c0 27 bf d0 clr [ %fp + -48 ]
400052cc: c0 27 bf d4 clr [ %fp + -44 ]
400052d0: c0 27 bf d8 clr [ %fp + -40 ]
400052d4: c0 27 bf dc clr [ %fp + -36 ]
400052d8: c0 27 bf e0 clr [ %fp + -32 ]
400052dc: c0 27 bf e4 clr [ %fp + -28 ]
400052e0: c0 27 bf e8 clr [ %fp + -24 ]
400052e4: c0 27 bf ec clr [ %fp + -20 ]
400052e8: c0 27 bf f0 clr [ %fp + -16 ]
400052ec: c0 27 bf f4 clr [ %fp + -12 ]
400052f0: c0 27 bf f8 clr [ %fp + -8 ]
400052f4: c0 27 bf fc clr [ %fp + -4 ]
rv = (*loc->handlers->fstat_h)( loc, &st );
400052f8: c2 00 a0 18 ld [ %g2 + 0x18 ], %g1
400052fc: 9f c0 40 00 call %g1
40005300: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
40005304: b0 92 20 00 orcc %o0, 0, %i0
40005308: 02 80 00 04 be 40005318 <rtems_filesystem_chmod+0xb4>
4000530c: 01 00 00 00 nop
errno = EROFS;
rv = -1;
}
return rv;
}
40005310: 81 c7 e0 08 ret
40005314: 81 e8 00 00 restore
uid_t uid = geteuid();
40005318: 40 00 03 01 call 40005f1c <geteuid>
4000531c: 01 00 00 00 nop
if ( uid == 0 || st.st_uid == uid ) {
40005320: 91 2a 20 10 sll %o0, 0x10, %o0
40005324: 91 32 20 10 srl %o0, 0x10, %o0
40005328: 80 a2 20 00 cmp %o0, 0
4000532c: 12 80 00 0c bne 4000535c <rtems_filesystem_chmod+0xf8>
40005330: c2 17 bf b2 lduh [ %fp + -78 ], %g1
rv = (*mt_entry->ops->fchmod_h)( loc, mode );
40005334: c2 07 20 0c ld [ %i4 + 0xc ], %g1
mode = (st.st_mode & ~mask) | (mode & mask);
40005338: d2 07 bf ac ld [ %fp + -84 ], %o1
rv = (*mt_entry->ops->fchmod_h)( loc, mode );
4000533c: c2 00 60 1c ld [ %g1 + 0x1c ], %g1
mode = (st.st_mode & ~mask) | (mode & mask);
40005340: b2 0e 6f ff and %i1, 0xfff, %i1
rv = (*mt_entry->ops->fchmod_h)( loc, mode );
40005344: 90 10 00 1d mov %i5, %o0
mode = (st.st_mode & ~mask) | (mode & mask);
40005348: 92 0a 70 00 and %o1, -4096, %o1
rv = (*mt_entry->ops->fchmod_h)( loc, mode );
4000534c: 9f c0 40 00 call %g1
40005350: 92 12 40 19 or %o1, %i1, %o1
if ( uid == 0 || st.st_uid == uid ) {
40005354: 81 c7 e0 08 ret
40005358: 91 e8 00 08 restore %g0, %o0, %o0
4000535c: 80 a0 40 08 cmp %g1, %o0
40005360: 22 bf ff f6 be,a 40005338 <rtems_filesystem_chmod+0xd4>
<== ALWAYS TAKEN
40005364: c2 07 20 0c ld [ %i4 + 0xc ], %g1
errno = EPERM;
40005368: 40 00 2d b9 call 40010a4c <__errno>
<== NOT EXECUTED
4000536c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005370: 82 10 20 01 mov 1, %g1
<== NOT EXECUTED
40005374: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
if ( mt_entry->writeable || rtems_filesystem_location_is_null( loc ) ) {
40005378: 81 c7 e0 08 ret
<== NOT EXECUTED
4000537c: 81 e8 00 00 restore
<== NOT EXECUTED
errno = EROFS;
40005380: 40 00 2d b3 call 40010a4c <__errno>
40005384: b0 10 3f ff mov -1, %i0
40005388: 82 10 20 1e mov 0x1e, %g1
4000538c: c2 22 00 00 st %g1, [ %o0 ]
}
40005390: 81 c7 e0 08 ret
40005394: 81 e8 00 00 restore
400233f0 <rtems_filesystem_default_pathconf>:
400233f0: 00 00 00 05 00 00 00 80 00 00 00 07 00 00 00 ff ................
40023400: 00 00 00 ff 00 00 04 00 00 00 00 00 00 00 00 00 ................
40023410: 00 00 00 01 00 00 00 00 00 00 00 00 00 00 00 00 ................
40008ec8 <rtems_filesystem_do_unmount>:
}
void rtems_filesystem_do_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
40008ec8: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_lock();
40008ecc: 7f ff f9 94 call 4000751c <rtems_libio_lock>
40008ed0: 01 00 00 00 nop
next = the_node->next;
40008ed4: c4 06 00 00 ld [ %i0 ], %g2
previous = the_node->previous;
40008ed8: c2 06 20 04 ld [ %i0 + 4 ], %g1
next->previous = previous;
40008edc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
rtems_libio_unlock();
40008ee0: 7f ff f9 94 call 40007530 <rtems_libio_unlock>
40008ee4: c4 20 40 00 st %g2, [ %g1 ]
release_with_count(global_loc, 1);
40008ee8: d0 06 20 20 ld [ %i0 + 0x20 ], %o0
40008eec: 40 00 00 14 call 40008f3c <release_with_count>
40008ef0: 92 10 20 01 mov 1, %o1
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);
40008ef4: c2 06 20 0c ld [ %i0 + 0xc ], %g1
40008ef8: c2 00 60 34 ld [ %g1 + 0x34 ], %g1
40008efc: 9f c0 40 00 call %g1
40008f00: 90 10 00 18 mov %i0, %o0
if (mt_entry->unmount_task != 0) {
40008f04: d0 06 20 3c ld [ %i0 + 0x3c ], %o0
40008f08: 80 a2 20 00 cmp %o0, 0
40008f0c: 02 80 00 07 be 40008f28 <rtems_filesystem_do_unmount+0x60>
<== NEVER TAKEN
40008f10: 01 00 00 00 nop
*/
RTEMS_INLINE_ROUTINE rtems_status_code rtems_event_transient_send(
rtems_id id
)
{
return rtems_event_system_send( id, RTEMS_EVENT_SYSTEM_TRANSIENT );
40008f14: 40 00 02 4c call 40009844 <rtems_event_system_send>
40008f18: 13 20 00 00 sethi %hi(0x80000000), %o1
rtems_status_code sc =
rtems_event_transient_send(mt_entry->unmount_task);
if (sc != RTEMS_SUCCESSFUL) {
40008f1c: 80 a2 20 00 cmp %o0, 0
40008f20: 32 80 00 04 bne,a 40008f30 <rtems_filesystem_do_unmount+0x68>
<== NEVER TAKEN
40008f24: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
<== NOT EXECUTED
rtems_fatal_error_occurred(0xdeadbeef);
}
}
free(mt_entry);
40008f28: 7f ff f8 96 call 40007180 <free>
<== NOT EXECUTED
40008f2c: 81 e8 00 00 restore
rtems_fatal_error_occurred(0xdeadbeef);
40008f30: 40 00 02 b5 call 40009a04 <rtems_fatal_error_occurred>
<== NOT EXECUTED
40008f34: 90 12 22 ef or %o0, 0x2ef, %o0
<== NOT EXECUTED
40008f38: 01 00 00 00 nop
<== NOT EXECUTED
40009340 <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;
40009340: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
40009344: c4 02 20 04 ld [ %o0 + 4 ], %g2
40009348: 86 00 40 02 add %g1, %g2, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
4000934c: 80 a0 40 03 cmp %g1, %g3
40009350: 22 80 00 17 be,a 400093ac <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NEVER TAKEN
40009354: 84 10 20 00 clr %g2
<== NOT EXECUTED
return c == '/' || c == '\\';
40009358: c8 48 40 00 ldsb [ %g1 ], %g4
4000935c: 80 a1 20 2f cmp %g4, 0x2f
40009360: 02 80 00 04 be 40009370 <rtems_filesystem_eval_path_eat_delimiter+0x30>
<== ALWAYS TAKEN
40009364: 80 a1 20 5c cmp %g4, 0x5c
40009368: 32 80 00 11 bne,a 400093ac <rtems_filesystem_eval_path_eat_delimiter+0x6c>
<== NOT EXECUTED
4000936c: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
++current;
40009370: 82 00 60 01 inc %g1
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40009374: 80 a0 c0 01 cmp %g3, %g1
40009378: 02 80 00 0d be 400093ac <rtems_filesystem_eval_path_eat_delimiter+0x6c>
4000937c: 84 10 20 00 clr %g2
40009380: c4 48 40 00 ldsb [ %g1 ], %g2
40009384: 80 a0 a0 2f cmp %g2, 0x2f
40009388: 02 bf ff fa be 40009370 <rtems_filesystem_eval_path_eat_delimiter+0x30>
4000938c: 80 a0 a0 5c cmp %g2, 0x5c
40009390: 22 bf ff f9 be,a 40009374 <rtems_filesystem_eval_path_eat_delimiter+0x34>
<== NEVER TAKEN
40009394: 82 00 60 01 inc %g1
<== NOT EXECUTED
40009398: 84 20 c0 01 sub %g3, %g1, %g2
++current;
4000939c: 86 10 00 01 mov %g1, %g3
}
ctx->path = current;
ctx->pathlen = (size_t) (end - current);
400093a0: c4 22 20 04 st %g2, [ %o0 + 4 ]
}
400093a4: 81 c3 e0 08 retl
400093a8: c6 22 00 00 st %g3, [ %o0 ]
ctx->path = current;
400093ac: c6 22 00 00 st %g3, [ %o0 ]
}
400093b0: 81 c3 e0 08 retl
400093b4: c4 22 20 04 st %g2, [ %o0 + 4 ]
40008648 <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
)
{
40008648: 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);
4000864c: 21 10 00 8d sethi %hi(0x40023400), %l0
{
40008650: ba 10 00 18 mov %i0, %i5
return &ctx->currentloc;
40008654: a2 06 20 18 add %i0, 0x18, %l1
status = (*config->eval_token)(ctx, arg, "..", 2);
40008658: a0 14 20 a0 or %l0, 0xa0, %l0
status = (*config->eval_token)(ctx, arg, ".", 1);
4000865c: 31 10 00 8d sethi %hi(0x40023400), %i0
40008660: b0 16 20 98 or %i0, 0x98, %i0 ! 40023498 <objects_info_table+0x78>
rtems_filesystem_eval_path_next_token(ctx);
40008664: 40 00 03 55 call 400093b8 <rtems_filesystem_eval_path_next_token>
40008668: 90 10 00 1d mov %i5, %o0
*tokenlen = ctx->tokenlen;
4000866c: f8 07 60 0c ld [ %i5 + 0xc ], %i4
if (tokenlen > 0) {
40008670: 80 a7 20 00 cmp %i4, 0
40008674: 02 80 00 19 be 400086d8 <rtems_filesystem_eval_path_generic+0x90>
40008678: f6 07 60 08 ld [ %i5 + 8 ], %i3
if ((*config->is_directory)(ctx, arg)) {
4000867c: c2 06 80 00 ld [ %i2 ], %g1
40008680: 92 10 00 19 mov %i1, %o1
40008684: 9f c0 40 00 call %g1
40008688: 90 10 00 1d mov %i5, %o0
4000868c: 80 a2 20 00 cmp %o0, 0
40008690: 02 80 00 60 be 40008810 <rtems_filesystem_eval_path_generic+0x1c8>
40008694: 80 a7 20 01 cmp %i4, 1
return tokenlen == 1 && token [0] == '.';
40008698: 02 80 00 12 be 400086e0 <rtems_filesystem_eval_path_generic+0x98>
4000869c: 80 a7 20 02 cmp %i4, 2
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
400086a0: 22 80 00 33 be,a 4000876c <rtems_filesystem_eval_path_generic+0x124>
400086a4: c2 4e c0 00 ldsb [ %i3 ], %g1
}
} else {
status = (*config->eval_token)(ctx, arg, token, tokenlen);
400086a8: c2 06 a0 04 ld [ %i2 + 4 ], %g1
400086ac: 96 10 00 1c mov %i4, %o3
400086b0: 94 10 00 1b mov %i3, %o2
400086b4: 92 10 00 19 mov %i1, %o1
400086b8: 9f c0 40 00 call %g1
400086bc: 90 10 00 1d mov %i5, %o0
}
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
400086c0: 80 a2 20 02 cmp %o0, 2
400086c4: 22 80 00 19 be,a 40008728 <rtems_filesystem_eval_path_generic+0xe0>
400086c8: c2 07 60 04 ld [ %i5 + 4 ], %g1
while (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_CONTINUE) {
400086cc: 80 a2 20 00 cmp %o0, 0
400086d0: 02 bf ff e5 be 40008664 <rtems_filesystem_eval_path_generic+0x1c>
400086d4: 01 00 00 00 nop
400086d8: 81 c7 e0 08 ret
400086dc: 81 e8 00 00 restore
return tokenlen == 1 && token [0] == '.';
400086e0: c2 4e c0 00 ldsb [ %i3 ], %g1
400086e4: 80 a0 60 2e cmp %g1, 0x2e
400086e8: 32 bf ff f1 bne,a 400086ac <rtems_filesystem_eval_path_generic+0x64>
400086ec: c2 06 a0 04 ld [ %i2 + 4 ], %g1
if (rtems_filesystem_eval_path_has_path(ctx)) {
400086f0: c2 07 60 04 ld [ %i5 + 4 ], %g1
400086f4: 80 a0 60 00 cmp %g1, 0
400086f8: 22 80 00 40 be,a 400087f8 <rtems_filesystem_eval_path_generic+0x1b0>
400086fc: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
status = (*config->eval_token)(ctx, arg, ".", 1);
40008700: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40008704: 96 10 20 01 mov 1, %o3
40008708: 94 10 00 18 mov %i0, %o2
4000870c: 92 10 00 19 mov %i1, %o1
40008710: 9f c0 40 00 call %g1
40008714: 90 10 00 1d mov %i5, %o0
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
40008718: 80 a2 20 02 cmp %o0, 2
4000871c: 12 bf ff ed bne 400086d0 <rtems_filesystem_eval_path_generic+0x88>
<== ALWAYS TAKEN
40008720: 80 a2 20 00 cmp %o0, 0
if (rtems_filesystem_eval_path_has_path(ctx)) {
40008724: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
40008728: 80 a0 60 00 cmp %g1, 0
4000872c: 12 80 00 04 bne 4000873c <rtems_filesystem_eval_path_generic+0xf4>
40008730: 01 00 00 00 nop
}
} else {
status = RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_DONE;
}
}
}
40008734: 81 c7 e0 08 ret
40008738: 81 e8 00 00 restore
rtems_filesystem_eval_path_eat_delimiter(ctx);
4000873c: 40 00 03 01 call 40009340 <rtems_filesystem_eval_path_eat_delimiter>
40008740: 90 10 00 1d mov %i5, %o0
(eval_flags & RTEMS_FS_ACCEPT_RESIDUAL_DELIMITERS) == 0
40008744: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
if (
40008748: 80 88 60 80 btst 0x80, %g1
4000874c: 02 80 00 06 be 40008764 <rtems_filesystem_eval_path_generic+0x11c>
40008750: b2 10 20 02 mov 2, %i1
|| rtems_filesystem_eval_path_has_path(ctx)
40008754: c2 07 60 04 ld [ %i5 + 4 ], %g1
40008758: 80 a0 60 00 cmp %g1, 0
4000875c: 02 bf ff f6 be 40008734 <rtems_filesystem_eval_path_generic+0xec>
40008760: 01 00 00 00 nop
rtems_filesystem_eval_path_error(ctx, ENOENT);
40008764: 40 00 00 4d call 40008898 <rtems_filesystem_eval_path_error>
40008768: 91 e8 00 1d restore %g0, %i5, %o0
return tokenlen == 2 && token [0] == '.' && token [1] == '.';
4000876c: 80 a0 60 2e cmp %g1, 0x2e
40008770: 32 bf ff cf bne,a 400086ac <rtems_filesystem_eval_path_generic+0x64>
40008774: c2 06 a0 04 ld [ %i2 + 4 ], %g1
40008778: c2 4e e0 01 ldsb [ %i3 + 1 ], %g1
4000877c: 80 a0 60 2e cmp %g1, 0x2e
40008780: 32 bf ff cb bne,a 400086ac <rtems_filesystem_eval_path_generic+0x64>
<== NEVER TAKEN
40008784: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
const rtems_filesystem_mount_table_entry_t *mt_entry = loc->mt_entry;
40008788: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
4000878c: d2 07 60 30 ld [ %i5 + 0x30 ], %o1
40008790: c4 00 60 0c ld [ %g1 + 0xc ], %g2
&& (*mt_entry->ops->are_nodes_equal_h)( loc, rootloc );
40008794: c6 02 60 14 ld [ %o1 + 0x14 ], %g3
40008798: 80 a0 40 03 cmp %g1, %g3
4000879c: 12 80 00 0a bne 400087c4 <rtems_filesystem_eval_path_generic+0x17c>
400087a0: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
400087a4: 9f c0 80 00 call %g2
400087a8: 90 10 00 11 mov %l1, %o0
400087ac: 80 a2 20 00 cmp %o0, 0
400087b0: 32 bf ff d5 bne,a 40008704 <rtems_filesystem_eval_path_generic+0xbc>
400087b4: c2 06 a0 04 ld [ %i2 + 4 ], %g1
400087b8: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
400087bc: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400087c0: c4 00 a0 10 ld [ %g2 + 0x10 ], %g2
return (*mt_entry->ops->are_nodes_equal_h)( loc, mt_fs_root );
400087c4: d2 00 60 24 ld [ %g1 + 0x24 ], %o1
400087c8: 9f c0 80 00 call %g2
400087cc: 90 10 00 11 mov %l1, %o0
} else if (is_fs_root(currentloc)) {
400087d0: 80 a2 20 00 cmp %o0, 0
400087d4: 12 80 00 12 bne 4000881c <rtems_filesystem_eval_path_generic+0x1d4>
400087d8: 96 10 20 02 mov 2, %o3
status = (*config->eval_token)(ctx, arg, "..", 2);
400087dc: c2 06 a0 04 ld [ %i2 + 4 ], %g1
400087e0: 94 10 00 10 mov %l0, %o2
400087e4: 92 10 00 19 mov %i1, %o1
400087e8: 9f c0 40 00 call %g1
400087ec: 90 10 00 1d mov %i5, %o0
if (status == RTEMS_FILESYSTEM_EVAL_PATH_GENERIC_NO_ENTRY) {
400087f0: 10 bf ff b5 b 400086c4 <rtems_filesystem_eval_path_generic+0x7c>
400087f4: 80 a2 20 02 cmp %o0, 2
if ((eval_flags & RTEMS_FS_REJECT_TERMINAL_DOT) == 0) {
400087f8: 80 88 61 00 btst 0x100, %g1
400087fc: 22 bf ff c2 be,a 40008704 <rtems_filesystem_eval_path_generic+0xbc>
40008800: c2 06 a0 04 ld [ %i2 + 4 ], %g1
rtems_filesystem_eval_path_error(ctx, EINVAL);
40008804: b2 10 20 16 mov 0x16, %i1
40008808: 40 00 00 24 call 40008898 <rtems_filesystem_eval_path_error>
4000880c: 91 e8 00 1d restore %g0, %i5, %o0
rtems_filesystem_eval_path_error(ctx, ENOTDIR);
40008810: b2 10 20 14 mov 0x14, %i1
40008814: 40 00 00 21 call 40008898 <rtems_filesystem_eval_path_error>
40008818: 91 e8 00 1d restore %g0, %i5, %o0
if (currentloc->mt_entry->mt_point_node != NULL) {
4000881c: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40008820: c4 00 60 20 ld [ %g1 + 0x20 ], %g2
40008824: 80 a0 a0 00 cmp %g2, 0
40008828: 22 bf ff b7 be,a 40008704 <rtems_filesystem_eval_path_generic+0xbc>
<== NEVER TAKEN
4000882c: c2 06 a0 04 ld [ %i2 + 4 ], %g1
<== NOT EXECUTED
size_t tokenlen = ctx->tokenlen;
40008830: c8 07 60 0c ld [ %i5 + 0xc ], %g4
ctx->path -= tokenlen;
40008834: c6 07 40 00 ld [ %i5 ], %g3
ctx->pathlen += tokenlen;
40008838: c4 07 60 04 ld [ %i5 + 4 ], %g2
ctx->path -= tokenlen;
4000883c: 86 20 c0 04 sub %g3, %g4, %g3
ctx->pathlen += tokenlen;
40008840: 84 00 80 04 add %g2, %g4, %g2
ctx->path -= tokenlen;
40008844: c6 27 40 00 st %g3, [ %i5 ]
rtems_filesystem_eval_path_restart(
40008848: b2 00 60 20 add %g1, 0x20, %i1
ctx->pathlen += tokenlen;
4000884c: c4 27 60 04 st %g2, [ %i5 + 4 ]
ctx->tokenlen = 0;
40008850: c0 27 60 0c clr [ %i5 + 0xc ]
40008854: 40 00 01 2a call 40008cfc <rtems_filesystem_eval_path_restart>
40008858: 91 e8 00 1d restore %g0, %i5, %o0
400093b8 <rtems_filesystem_eval_path_next_token>:
const char *current = ctx->path;
400093b8: c2 02 00 00 ld [ %o0 ], %g1
const char *end = current + ctx->pathlen;
400093bc: c6 02 20 04 ld [ %o0 + 4 ], %g3
400093c0: 86 00 40 03 add %g1, %g3, %g3
while (current != end && rtems_filesystem_is_delimiter(*current)) {
400093c4: 80 a0 40 03 cmp %g1, %g3
400093c8: 32 80 00 09 bne,a 400093ec <rtems_filesystem_eval_path_next_token+0x34>
400093cc: c4 48 40 00 ldsb [ %g1 ], %g2
400093d0: 10 80 00 20 b 40009450 <rtems_filesystem_eval_path_next_token+0x98>
400093d4: 9a 10 20 00 clr %o5
++current;
400093d8: 82 00 60 01 inc %g1
while (current != end && rtems_filesystem_is_delimiter(*current)) {
400093dc: 80 a0 c0 01 cmp %g3, %g1
400093e0: 22 80 00 22 be,a 40009468 <rtems_filesystem_eval_path_next_token+0xb0>
400093e4: 82 10 00 03 mov %g3, %g1
400093e8: c4 48 40 00 ldsb [ %g1 ], %g2
400093ec: 80 a0 a0 2f cmp %g2, 0x2f
400093f0: 02 bf ff fa be 400093d8 <rtems_filesystem_eval_path_next_token+0x20>
400093f4: 80 a0 a0 5c cmp %g2, 0x5c
400093f8: 22 bf ff f9 be,a 400093dc <rtems_filesystem_eval_path_next_token+0x24>
400093fc: 82 00 60 01 inc %g1
ctx->path = current;
40009400: c2 22 00 00 st %g1, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
40009404: 9a 20 c0 01 sub %g3, %g1, %o5
40009408: da 22 20 04 st %o5, [ %o0 + 4 ]
4000940c: 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)) {
40009410: 80 a0 a0 5c cmp %g2, 0x5c
40009414: 02 80 00 1f be 40009490 <rtems_filesystem_eval_path_next_token+0xd8>
<== NEVER TAKEN
40009418: 80 a0 a0 2f cmp %g2, 0x2f
4000941c: 02 80 00 1e be 40009494 <rtems_filesystem_eval_path_next_token+0xdc>
<== NEVER TAKEN
40009420: 88 10 00 0d mov %o5, %g4
40009424: 10 80 00 07 b 40009440 <rtems_filesystem_eval_path_next_token+0x88>
40009428: 84 10 00 01 mov %g1, %g2
4000942c: 80 a1 20 2f cmp %g4, 0x2f
40009430: 02 80 00 10 be 40009470 <rtems_filesystem_eval_path_next_token+0xb8>
40009434: 80 a1 20 5c cmp %g4, 0x5c
40009438: 02 80 00 0f be 40009474 <rtems_filesystem_eval_path_next_token+0xbc>
<== NEVER TAKEN
4000943c: 88 20 c0 02 sub %g3, %g2, %g4
++current;
40009440: 84 00 a0 01 inc %g2
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
40009444: 80 a0 80 03 cmp %g2, %g3
40009448: 32 bf ff f9 bne,a 4000942c <rtems_filesystem_eval_path_next_token+0x74>
4000944c: c8 48 80 00 ldsb [ %g2 ], %g4
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40009450: 88 10 20 00 clr %g4
}
ctx->path = current;
40009454: c6 22 00 00 st %g3, [ %o0 ]
ctx->pathlen = (size_t) (end - current);
40009458: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->token = begin;
4000945c: 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);
}
40009460: 81 c3 e0 08 retl
40009464: da 22 20 0c st %o5, [ %o0 + 0xc ]
while (current != end && rtems_filesystem_is_delimiter(*current)) {
40009468: 10 bf ff fa b 40009450 <rtems_filesystem_eval_path_next_token+0x98>
4000946c: 9a 10 20 00 clr %o5
40009470: 88 20 c0 02 sub %g3, %g2, %g4
40009474: 9a 20 80 01 sub %g2, %g1, %o5
++current;
40009478: 86 10 00 02 mov %g2, %g3
ctx->pathlen = (size_t) (end - current);
4000947c: c8 22 20 04 st %g4, [ %o0 + 4 ]
ctx->path = current;
40009480: c6 22 00 00 st %g3, [ %o0 ]
ctx->token = begin;
40009484: c2 22 20 08 st %g1, [ %o0 + 8 ]
}
40009488: 81 c3 e0 08 retl
4000948c: da 22 20 0c st %o5, [ %o0 + 0xc ]
while (current != end && !rtems_filesystem_is_delimiter(*current)) {
40009490: 88 10 00 0d mov %o5, %g4
<== NOT EXECUTED
40009494: 86 10 00 01 mov %g1, %g3
<== NOT EXECUTED
40009498: 10 bf ff ef b 40009454 <rtems_filesystem_eval_path_next_token+0x9c>
<== NOT EXECUTED
4000949c: 9a 10 20 00 clr %o5
<== NOT EXECUTED
40008d60 <rtems_filesystem_eval_path_recursive>:
{
40008d60: 9d e3 bf a0 save %sp, -96, %sp
if (pathlen > 0) {
40008d64: 80 a6 a0 00 cmp %i2, 0
40008d68: 02 80 00 22 be 40008df0 <rtems_filesystem_eval_path_recursive+0x90>
<== NEVER TAKEN
40008d6c: ba 10 00 18 mov %i0, %i5
if (ctx->recursionlevel < RTEMS_FILESYSTEM_SYMLOOP_MAX) {
40008d70: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
40008d74: 80 a0 60 1f cmp %g1, 0x1f
40008d78: 14 80 00 20 bg 40008df8 <rtems_filesystem_eval_path_recursive+0x98>
40008d7c: 01 00 00 00 nop
return c == '/' || c == '\\';
40008d80: c4 4e 40 00 ldsb [ %i1 ], %g2
const char *saved_path = ctx->path;
40008d84: f6 06 00 00 ld [ %i0 ], %i3
if (rtems_filesystem_is_delimiter(path [0])) {
40008d88: 80 a0 a0 2f cmp %g2, 0x2f
40008d8c: 02 80 00 1d be 40008e00 <rtems_filesystem_eval_path_recursive+0xa0>
<== NEVER TAKEN
40008d90: f8 06 20 04 ld [ %i0 + 4 ], %i4
40008d94: 80 a0 a0 5c cmp %g2, 0x5c
40008d98: 02 80 00 1b be 40008e04 <rtems_filesystem_eval_path_recursive+0xa4>
<== NEVER TAKEN
40008d9c: 92 07 60 30 add %i5, 0x30, %o1
++ctx->recursionlevel;
40008da0: 82 00 60 01 inc %g1
ctx->path = path;
40008da4: f2 27 40 00 st %i1, [ %i5 ]
ctx->pathlen = pathlen;
40008da8: f4 27 60 04 st %i2, [ %i5 + 4 ]
++ctx->recursionlevel;
40008dac: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
(*ctx->currentloc.mt_entry->ops->eval_path_h)(ctx);
40008db0: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
40008db4: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40008db8: c2 00 60 08 ld [ %g1 + 8 ], %g1
40008dbc: 9f c0 40 00 call %g1
40008dc0: 90 10 00 1d mov %i5, %o0
while (ctx->pathlen > 0) {
40008dc4: c2 07 60 04 ld [ %i5 + 4 ], %g1
40008dc8: 80 a0 60 00 cmp %g1, 0
40008dcc: 32 bf ff fa bne,a 40008db4 <rtems_filesystem_eval_path_recursive+0x54>
<== NEVER TAKEN
40008dd0: c2 07 60 2c ld [ %i5 + 0x2c ], %g1
<== NOT EXECUTED
--ctx->recursionlevel;
40008dd4: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
40008dd8: 82 00 7f ff add %g1, -1, %g1
ctx->path = saved_path;
40008ddc: f6 27 40 00 st %i3, [ %i5 ]
--ctx->recursionlevel;
40008de0: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
ctx->pathlen = saved_pathlen;
40008de4: f8 27 60 04 st %i4, [ %i5 + 4 ]
}
40008de8: 81 c7 e0 08 ret
40008dec: 81 e8 00 00 restore
rtems_filesystem_eval_path_error(ctx, ENOENT);
40008df0: 7f ff fe aa call 40008898 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40008df4: 93 e8 20 02 restore %g0, 2, %o1
<== NOT EXECUTED
rtems_filesystem_eval_path_error(ctx, ELOOP);
40008df8: 7f ff fe a8 call 40008898 <rtems_filesystem_eval_path_error>
40008dfc: 93 e8 20 5c restore %g0, 0x5c, %o1
rtems_filesystem_eval_path_restart(ctx, &ctx->rootloc);
40008e00: 92 07 60 30 add %i5, 0x30, %o1
<== NOT EXECUTED
40008e04: 7f ff ff be call 40008cfc <rtems_filesystem_eval_path_restart>
<== NOT EXECUTED
40008e08: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40008e0c: 10 bf ff e5 b 40008da0 <rtems_filesystem_eval_path_recursive+0x40>
<== NOT EXECUTED
40008e10: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
40008bb4 <rtems_filesystem_eval_path_start_with_parent>:
{
40008bb4: 9d e3 bf a0 save %sp, -96, %sp
size_t pathlen = strlen(path);
40008bb8: 40 00 34 b3 call 40015e84 <strlen>
40008bbc: 90 10 00 19 mov %i1, %o0
while (pathlen > 0) {
40008bc0: a0 92 20 00 orcc %o0, 0, %l0
40008bc4: 02 80 00 32 be 40008c8c <rtems_filesystem_eval_path_start_with_parent+0xd8>
40008bc8: a2 10 00 19 mov %i1, %l1
size_t i = pathlen - 1;
40008bcc: ba 04 3f ff add %l0, -1, %i5
return c == '/' || c == '\\';
40008bd0: c2 4e 40 1d ldsb [ %i1 + %i5 ], %g1
if (rtems_filesystem_is_delimiter(path [i])) {
40008bd4: 80 a0 60 2f cmp %g1, 0x2f
40008bd8: 02 80 00 30 be 40008c98 <rtems_filesystem_eval_path_start_with_parent+0xe4>
40008bdc: 80 a0 60 5c cmp %g1, 0x5c
40008be0: 12 80 00 0c bne 40008c10 <rtems_filesystem_eval_path_start_with_parent+0x5c>
<== ALWAYS TAKEN
40008be4: 80 a7 60 00 cmp %i5, 0
40008be8: 10 80 00 2e b 40008ca0 <rtems_filesystem_eval_path_start_with_parent+0xec>
<== NOT EXECUTED
40008bec: ba 10 00 10 mov %l0, %i5
<== NOT EXECUTED
40008bf0: c4 4e 40 01 ldsb [ %i1 + %g1 ], %g2
40008bf4: 80 a0 a0 2f cmp %g2, 0x2f
40008bf8: 02 80 00 21 be 40008c7c <rtems_filesystem_eval_path_start_with_parent+0xc8>
40008bfc: 80 a0 a0 5c cmp %g2, 0x5c
40008c00: 02 80 00 20 be 40008c80 <rtems_filesystem_eval_path_start_with_parent+0xcc>
<== NEVER TAKEN
40008c04: a2 10 00 19 mov %i1, %l1
size_t i = pathlen - 1;
40008c08: ba 10 00 01 mov %g1, %i5
while (pathlen > 0) {
40008c0c: 80 a7 60 00 cmp %i5, 0
40008c10: 12 bf ff f8 bne 40008bf0 <rtems_filesystem_eval_path_start_with_parent+0x3c>
40008c14: 82 07 7f ff add %i5, -1, %g1
parentpath = ".";
40008c18: 23 10 00 8d sethi %hi(0x40023400), %l1
parentpathlen = 1;
40008c1c: ba 10 20 01 mov 1, %i5
parentpath = ".";
40008c20: a2 14 60 98 or %l1, 0x98, %l1
&rtems_filesystem_root,
40008c24: 7f ff fd 42 call 4000812c <rtems_current_user_env_get>
40008c28: 01 00 00 00 nop
&rtems_filesystem_current
40008c2c: 7f ff fd 40 call 4000812c <rtems_current_user_env_get>
40008c30: a4 10 00 08 mov %o0, %l2
currentloc = rtems_filesystem_eval_path_start_with_root_and_current(
40008c34: 98 04 a0 04 add %l2, 4, %o4
40008c38: 9a 10 00 08 mov %o0, %o5
40008c3c: 96 10 00 1c mov %i4, %o3
40008c40: 94 10 00 1d mov %i5, %o2
40008c44: 92 10 00 11 mov %l1, %o1
40008c48: 7f ff ff 79 call 40008a2c <rtems_filesystem_eval_path_start_with_root_and_current>
40008c4c: 90 10 00 18 mov %i0, %o0
rtems_filesystem_location_clone(parentloc, currentloc);
40008c50: 92 10 00 08 mov %o0, %o1
40008c54: 40 00 29 80 call 40013254 <rtems_filesystem_location_clone>
40008c58: 90 10 00 1b mov %i3, %o0
ctx->path = name;
40008c5c: f2 26 00 00 st %i1, [ %i0 ]
rtems_filesystem_eval_path_continue(ctx);
40008c60: 90 10 00 18 mov %i0, %o0
ctx->pathlen = namelen;
40008c64: e0 26 20 04 st %l0, [ %i0 + 4 ]
return &ctx->currentloc;
40008c68: b0 06 20 18 add %i0, 0x18, %i0
rtems_filesystem_eval_path_continue(ctx);
40008c6c: 7f ff ff 53 call 400089b8 <rtems_filesystem_eval_path_continue>
40008c70: f4 26 3f f8 st %i2, [ %i0 + -8 ]
}
40008c74: 81 c7 e0 08 ret
40008c78: 81 e8 00 00 restore
name = path + parentpathlen;
40008c7c: a2 10 00 19 mov %i1, %l1
40008c80: a0 24 00 1d sub %l0, %i5, %l0
40008c84: 10 bf ff e8 b 40008c24 <rtems_filesystem_eval_path_start_with_parent+0x70>
40008c88: b2 06 40 1d add %i1, %i5, %i1
return 0;
40008c8c: ba 10 20 00 clr %i5
const char *name = NULL;
40008c90: 10 bf ff e5 b 40008c24 <rtems_filesystem_eval_path_start_with_parent+0x70>
40008c94: b2 10 20 00 clr %i1
if (rtems_filesystem_is_delimiter(path [i])) {
40008c98: ba 10 00 10 mov %l0, %i5
name = path + parentpathlen;
40008c9c: a2 10 00 19 mov %i1, %l1
if (rtems_filesystem_is_delimiter(path [i])) {
40008ca0: a0 10 20 00 clr %l0
name = path + parentpathlen;
40008ca4: 10 bf ff e0 b 40008c24 <rtems_filesystem_eval_path_start_with_parent+0x70>
40008ca8: b2 06 40 1d add %i1, %i5, %i1
40008a2c <rtems_filesystem_eval_path_start_with_root_and_current>:
{
40008a2c: 9d e3 bf 98 save %sp, -104, %sp
memset(ctx, 0, sizeof(*ctx));
40008a30: 94 10 20 30 mov 0x30, %o2
40008a34: 92 10 20 00 clr %o1
40008a38: 40 00 33 34 call 40015708 <memset>
40008a3c: 90 06 20 08 add %i0, 8, %o0
ctx->path = path;
40008a40: f2 26 00 00 st %i1, [ %i0 ]
if (ctx->pathlen > 0) {
40008a44: 80 a6 a0 00 cmp %i2, 0
ctx->pathlen = pathlen;
40008a48: f4 26 20 04 st %i2, [ %i0 + 4 ]
if (ctx->pathlen > 0) {
40008a4c: 02 80 00 1d be 40008ac0 <rtems_filesystem_eval_path_start_with_root_and_current+0x94>
40008a50: f6 26 20 10 st %i3, [ %i0 + 0x10 ]
char c = ctx->path [0];
40008a54: f6 0e 40 00 ldub [ %i1 ], %i3
ctx->rootloc = rtems_filesystem_global_location_obtain(global_root_ptr);
40008a58: 40 00 01 65 call 40008fec <rtems_filesystem_global_location_obtain>
40008a5c: 90 10 00 1c mov %i4, %o0
return c == '/' || c == '\\';
40008a60: 83 2e e0 18 sll %i3, 0x18, %g1
40008a64: 83 38 60 18 sra %g1, 0x18, %g1
if (rtems_filesystem_is_delimiter(c)) {
40008a68: 80 a0 60 2f cmp %g1, 0x2f
40008a6c: 02 80 00 2f be 40008b28 <rtems_filesystem_eval_path_start_with_root_and_current+0xfc>
40008a70: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
40008a74: 80 a0 60 5c cmp %g1, 0x5c
40008a78: 22 80 00 2d be,a 40008b2c <rtems_filesystem_eval_path_start_with_root_and_current+0x100>
<== NEVER TAKEN
40008a7c: c4 06 00 00 ld [ %i0 ], %g2
<== NOT EXECUTED
ctx->startloc = rtems_filesystem_global_location_obtain(
40008a80: 40 00 01 5b call 40008fec <rtems_filesystem_global_location_obtain>
40008a84: 90 10 00 1d mov %i5, %o0
40008a88: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
40008a8c: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
40008a90: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40008a94: c2 00 40 00 ld [ %g1 ], %g1
40008a98: 9f c0 40 00 call %g1
40008a9c: ba 06 20 18 add %i0, 0x18, %i5
rtems_filesystem_location_clone(
40008aa0: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40008aa4: 40 00 29 ec call 40013254 <rtems_filesystem_location_clone>
40008aa8: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_continue(ctx);
40008aac: 90 10 00 18 mov %i0, %o0
40008ab0: 7f ff ff c2 call 400089b8 <rtems_filesystem_eval_path_continue>
40008ab4: b0 10 00 1d mov %i5, %i0
}
40008ab8: 81 c7 e0 08 ret
40008abc: 81 e8 00 00 restore
rtems_filesystem_global_location_t *global_loc = NULL;
40008ac0: c0 27 bf fc clr [ %fp + -4 ]
return rtems_filesystem_global_location_obtain( &global_loc );
40008ac4: 40 00 01 4a call 40008fec <rtems_filesystem_global_location_obtain>
40008ac8: 90 07 bf fc add %fp, -4, %o0
ctx->rootloc = rtems_filesystem_global_location_obtain_null();
40008acc: d0 26 20 30 st %o0, [ %i0 + 0x30 ]
40008ad0: 90 07 bf fc add %fp, -4, %o0
40008ad4: 40 00 01 46 call 40008fec <rtems_filesystem_global_location_obtain>
40008ad8: c0 27 bf fc clr [ %fp + -4 ]
ctx->startloc = rtems_filesystem_global_location_obtain_null();
40008adc: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
errno = ENOENT;
40008ae0: 40 00 30 fa call 40014ec8 <__errno>
40008ae4: ba 06 20 18 add %i0, 0x18, %i5
40008ae8: 82 10 20 02 mov 2, %g1
40008aec: c2 22 00 00 st %g1, [ %o0 ]
40008af0: d0 06 20 34 ld [ %i0 + 0x34 ], %o0
40008af4: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
(*mt_entry->ops->lock_h)( mt_entry );
40008af8: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40008afc: c2 00 40 00 ld [ %g1 ], %g1
40008b00: 9f c0 40 00 call %g1
40008b04: 01 00 00 00 nop
rtems_filesystem_location_clone(
40008b08: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40008b0c: 40 00 29 d2 call 40013254 <rtems_filesystem_location_clone>
40008b10: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_continue(ctx);
40008b14: 90 10 00 18 mov %i0, %o0
40008b18: 7f ff ff a8 call 400089b8 <rtems_filesystem_eval_path_continue>
40008b1c: b0 10 00 1d mov %i5, %i0
}
40008b20: 81 c7 e0 08 ret
40008b24: 81 e8 00 00 restore
++ctx->path;
40008b28: c4 06 00 00 ld [ %i0 ], %g2
--ctx->pathlen;
40008b2c: c2 06 20 04 ld [ %i0 + 4 ], %g1
++ctx->path;
40008b30: 84 00 a0 01 inc %g2
--ctx->pathlen;
40008b34: 82 00 7f ff add %g1, -1, %g1
++ctx->path;
40008b38: c4 26 00 00 st %g2, [ %i0 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
40008b3c: 90 06 20 30 add %i0, 0x30, %o0
--ctx->pathlen;
40008b40: c2 26 20 04 st %g1, [ %i0 + 4 ]
ctx->startloc = rtems_filesystem_global_location_obtain(
40008b44: 40 00 01 2a call 40008fec <rtems_filesystem_global_location_obtain>
40008b48: ba 06 20 18 add %i0, 0x18, %i5
40008b4c: d0 26 20 34 st %o0, [ %i0 + 0x34 ]
40008b50: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
40008b54: c2 02 20 0c ld [ %o0 + 0xc ], %g1
40008b58: c2 00 40 00 ld [ %g1 ], %g1
40008b5c: 9f c0 40 00 call %g1
40008b60: 01 00 00 00 nop
rtems_filesystem_location_clone(
40008b64: d2 06 20 34 ld [ %i0 + 0x34 ], %o1
40008b68: 40 00 29 bb call 40013254 <rtems_filesystem_location_clone>
40008b6c: 90 10 00 1d mov %i5, %o0
rtems_filesystem_eval_path_continue(ctx);
40008b70: 90 10 00 18 mov %i0, %o0
40008b74: 7f ff ff 91 call 400089b8 <rtems_filesystem_eval_path_continue>
40008b78: b0 10 00 1d mov %i5, %i0
}
40008b7c: 81 c7 e0 08 ret
40008b80: 81 e8 00 00 restore
400134f0 <rtems_filesystem_get_mount_handler>:
rtems_filesystem_fsmount_me_t
rtems_filesystem_get_mount_handler(
const char *type
)
{
400134f0: 9d e3 bf 98 save %sp, -104, %sp
400134f4: 82 10 00 18 mov %i0, %g1
find_arg fa = {
400134f8: c0 27 bf fc clr [ %fp + -4 ]
400134fc: b0 10 20 00 clr %i0
.type = type,
.mount_h = NULL
};
if ( type != NULL ) {
40013500: 80 a0 60 00 cmp %g1, 0
40013504: 02 80 00 07 be 40013520 <rtems_filesystem_get_mount_handler+0x30>
<== NEVER TAKEN
40013508: c2 27 bf f8 st %g1, [ %fp + -8 ]
rtems_filesystem_iterate( find_handler, &fa );
4001350c: 92 07 bf f8 add %fp, -8, %o1
40013510: 11 10 00 4d sethi %hi(0x40013400), %o0
40013514: 7f ff ff cb call 40013440 <rtems_filesystem_iterate>
40013518: 90 12 20 0c or %o0, 0xc, %o0 ! 4001340c <find_handler>
4001351c: f0 07 bf fc ld [ %fp + -4 ], %i0
}
return fa.mount_h;
}
40013520: 81 c7 e0 08 ret
40013524: 81 e8 00 00 restore
4000913c <rtems_filesystem_global_location_assign>:
{
4000913c: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40009140: 91 d0 20 09 ta 9
<== NOT EXECUTED
lhs_global_loc = *lhs_global_loc_ptr;
40009144: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
*lhs_global_loc_ptr = rhs_global_loc;
40009148: d2 20 80 00 st %o1, [ %g2 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000914c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009150: 01 00 00 00 nop
rtems_filesystem_global_location_release(lhs_global_loc, true);
40009154: 92 10 20 01 mov 1, %o1 ! 1 <_TLS_Alignment>
40009158: 82 13 c0 00 mov %o7, %g1
4000915c: 7f ff ff de call 400090d4 <rtems_filesystem_global_location_release>
40009160: 9e 10 40 00 mov %g1, %o7
40008fec <rtems_filesystem_global_location_obtain>:
{
40008fec: 9d e3 bf 98 save %sp, -104, %sp
if (deferred_released_global_locations != NULL) {
40008ff0: 3b 10 00 98 sethi %hi(0x40026000), %i5
40008ff4: c2 07 63 6c ld [ %i5 + 0x36c ], %g1 ! 4002636c <deferred_released_global_locations>
40008ff8: 80 a0 60 00 cmp %g1, 0
40008ffc: 02 80 00 1e be 40009074 <rtems_filesystem_global_location_obtain+0x88>
40009000: 01 00 00 00 nop
40009004: ba 17 63 6c or %i5, 0x36c, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40009008: 91 d0 20 09 ta 9
<== NOT EXECUTED
current = deferred_released_global_locations;
4000900c: d0 07 40 00 ld [ %i5 ], %o0
if (current != NULL) {
40009010: 80 a2 20 00 cmp %o0, 0
40009014: 02 80 00 07 be 40009030 <rtems_filesystem_global_location_obtain+0x44>
<== NEVER TAKEN
40009018: 92 10 20 00 clr %o1
<== NOT EXECUTED
deferred_released_global_locations = current->deferred_released_next;
4000901c: c4 02 20 1c ld [ %o0 + 0x1c ], %g2
<== NOT EXECUTED
count = current->deferred_released_count;
40009020: d2 02 20 20 ld [ %o0 + 0x20 ], %o1
<== NOT EXECUTED
deferred_released_global_locations = current->deferred_released_next;
40009024: c4 27 40 00 st %g2, [ %i5 ]
<== NOT EXECUTED
current->deferred_released_next = NULL;
40009028: c0 22 20 1c clr [ %o0 + 0x1c ]
<== NOT EXECUTED
current->deferred_released_count = 0;
4000902c: c0 22 20 20 clr [ %o0 + 0x20 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009030: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009034: 01 00 00 00 nop
if (current != NULL) {
40009038: 80 a2 20 00 cmp %o0, 0
4000903c: 02 80 00 0e be 40009074 <rtems_filesystem_global_location_obtain+0x88>
<== NEVER TAKEN
40009040: 01 00 00 00 nop
release_with_count(current, count);
40009044: 7f ff ff be call 40008f3c <release_with_count>
40009048: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000904c: 91 d0 20 09 ta 9
<== NOT EXECUTED
current = deferred_released_global_locations;
40009050: d0 07 40 00 ld [ %i5 ], %o0
if (current != NULL) {
40009054: 80 a2 20 00 cmp %o0, 0
40009058: 12 bf ff f1 bne 4000901c <rtems_filesystem_global_location_obtain+0x30>
4000905c: 92 10 20 00 clr %o1
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009060: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009064: 01 00 00 00 nop
if (current != NULL) {
40009068: 80 a2 20 00 cmp %o0, 0
4000906c: 12 bf ff f6 bne 40009044 <rtems_filesystem_global_location_obtain+0x58>
<== NEVER TAKEN
40009070: 01 00 00 00 nop
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40009074: 91 d0 20 09 ta 9
<== NOT EXECUTED
global_loc = *global_loc_ptr;
40009078: f0 06 00 00 ld [ %i0 ], %i0
if (global_loc == NULL || !global_loc->location.mt_entry->mounted) {
4000907c: 80 a6 20 00 cmp %i0, 0
40009080: 02 80 00 07 be 4000909c <rtems_filesystem_global_location_obtain+0xb0>
40009084: 01 00 00 00 nop
40009088: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
4000908c: c4 08 a0 28 ldub [ %g2 + 0x28 ], %g2
40009090: 80 a0 a0 00 cmp %g2, 0
40009094: 32 80 00 0a bne,a 400090bc <rtems_filesystem_global_location_obtain+0xd0>
40009098: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
errno = ENXIO;
4000909c: 40 00 2f 8b call 40014ec8 <__errno>
400090a0: c2 27 bf fc st %g1, [ %fp + -4 ]
400090a4: 84 10 20 06 mov 6, %g2
<== NOT EXECUTED
400090a8: c4 22 00 00 st %g2, [ %o0 ]
<== NOT EXECUTED
global_loc = &rtems_filesystem_global_location_null;
400090ac: 31 10 00 94 sethi %hi(0x40025000), %i0
<== NOT EXECUTED
400090b0: c2 07 bf fc ld [ %fp + -4 ], %g1
<== NOT EXECUTED
400090b4: b0 16 21 2c or %i0, 0x12c, %i0
<== NOT EXECUTED
++global_loc->reference_count;
400090b8: c4 06 20 18 ld [ %i0 + 0x18 ], %g2
<== NOT EXECUTED
400090bc: 84 00 a0 01 inc %g2
<== NOT EXECUTED
400090c0: c4 26 20 18 st %g2, [ %i0 + 0x18 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400090c4: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400090c8: 01 00 00 00 nop
}
400090cc: 81 c7 e0 08 ret
400090d0: 81 e8 00 00 restore
400090d4 <rtems_filesystem_global_location_release>:
if (!deferred) {
400090d4: 80 a2 60 00 cmp %o1, 0
400090d8: 22 80 00 16 be,a 40009130 <rtems_filesystem_global_location_release+0x5c>
400090dc: 92 10 20 01 mov 1, %o1
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400090e0: 91 d0 20 09 ta 9
<== NOT EXECUTED
if (global_loc->deferred_released_count == 0) {
400090e4: c6 02 20 20 ld [ %o0 + 0x20 ], %g3
400090e8: 80 a0 e0 00 cmp %g3, 0
400090ec: 22 80 00 08 be,a 4000910c <rtems_filesystem_global_location_release+0x38>
400090f0: 07 10 00 98 sethi %hi(0x40026000), %g3
++global_loc->deferred_released_count;
400090f4: 86 00 e0 01 inc %g3
<== NOT EXECUTED
400090f8: c6 22 20 20 st %g3, [ %o0 + 0x20 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400090fc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009100: 01 00 00 00 nop
}
40009104: 81 c3 e0 08 retl
40009108: 01 00 00 00 nop
rtems_filesystem_global_location_t *head =
4000910c: c8 00 e3 6c ld [ %g3 + 0x36c ], %g4
global_loc->deferred_released_next = head;
40009110: c8 22 20 1c st %g4, [ %o0 + 0x1c ]
global_loc->deferred_released_count = 1;
40009114: 88 10 20 01 mov 1, %g4
deferred_released_global_locations = global_loc;
40009118: d0 20 e3 6c st %o0, [ %g3 + 0x36c ]
global_loc->deferred_released_count = 1;
4000911c: c8 22 20 20 st %g4, [ %o0 + 0x20 ]
40009120: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009124: 01 00 00 00 nop
}
40009128: 81 c3 e0 08 retl
4000912c: 01 00 00 00 nop
release_with_count(global_loc, 1);
40009130: 82 13 c0 00 mov %o7, %g1
40009134: 7f ff ff 82 call 40008f3c <release_with_count>
40009138: 9e 10 40 00 mov %g1, %o7
40006f98 <rtems_filesystem_initialize>:
/*
* Default mode for created files.
*/
void rtems_filesystem_initialize( void )
{
40006f98: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
const rtems_filesystem_mount_configuration *root_config =
&rtems_filesystem_root_configuration;
rv = mount(
40006f9c: 05 10 00 8b sethi %hi(0x40022c00), %g2
40006fa0: 82 10 a0 94 or %g2, 0x94, %g1 ! 40022c94 <rtems_filesystem_root_configuration>
40006fa4: d0 00 a0 94 ld [ %g2 + 0x94 ], %o0
40006fa8: d8 00 60 10 ld [ %g1 + 0x10 ], %o4
40006fac: d6 00 60 0c ld [ %g1 + 0xc ], %o3
40006fb0: d4 00 60 08 ld [ %g1 + 8 ], %o2
40006fb4: 40 00 02 bb call 40007aa0 <mount>
40006fb8: d2 00 60 04 ld [ %g1 + 4 ], %o1
root_config->target,
root_config->filesystemtype,
root_config->options,
root_config->data
);
if ( rv != 0 )
40006fbc: 80 a2 20 00 cmp %o0, 0
40006fc0: 12 80 00 0a bne 40006fe8 <rtems_filesystem_initialize+0x50>
<== NEVER TAKEN
40006fc4: 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 );
40006fc8: 11 10 00 8c sethi %hi(0x40023000), %o0
40006fcc: 40 00 02 6d call 40007980 <mkdir>
40006fd0: 90 12 22 f8 or %o0, 0x2f8, %o0 ! 400232f8 <IMFS_node_control_sym_link+0x10>
if ( rv != 0 )
40006fd4: 80 a2 20 00 cmp %o0, 0
40006fd8: 12 80 00 07 bne 40006ff4 <rtems_filesystem_initialize+0x5c>
<== NEVER TAKEN
40006fdc: 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.
*/
}
40006fe0: 81 c7 e0 08 ret
40006fe4: 81 e8 00 00 restore
rtems_fatal_error_occurred( 0xABCD0002 );
40006fe8: 11 2a f3 40 sethi %hi(0xabcd0000), %o0
<== NOT EXECUTED
40006fec: 40 00 0a 86 call 40009a04 <rtems_fatal_error_occurred>
<== NOT EXECUTED
40006ff0: 90 12 20 02 or %o0, 2, %o0 ! abcd0002 <RAM_END+0x6b8d0002>
<== NOT EXECUTED
rtems_fatal_error_occurred( 0xABCD0003 );
40006ff4: 40 00 0a 84 call 40009a04 <rtems_fatal_error_occurred>
<== NOT EXECUTED
40006ff8: 90 12 20 03 or %o0, 3, %o0
<== NOT EXECUTED
40006ffc: 01 00 00 00 nop
<== NOT EXECUTED
40013440 <rtems_filesystem_iterate>:
{
40013440: 9d e3 bf a0 save %sp, -96, %sp
while ( table_entry->type && !stop ) {
40013444: 3b 10 00 8b sethi %hi(0x40022c00), %i5
40013448: c2 07 61 10 ld [ %i5 + 0x110 ], %g1 ! 40022d10 <rtems_filesystem_table>
4001344c: 80 a0 60 00 cmp %g1, 0
40013450: 12 80 00 06 bne 40013468 <rtems_filesystem_iterate+0x28>
<== ALWAYS TAKEN
40013454: ba 17 61 10 or %i5, 0x110, %i5
40013458: 30 80 00 0f b,a 40013494 <rtems_filesystem_iterate+0x54>
<== NOT EXECUTED
4001345c: 80 a2 20 00 cmp %o0, 0
40013460: 32 80 00 22 bne,a 400134e8 <rtems_filesystem_iterate+0xa8>
40013464: b8 0f 20 ff and %i4, 0xff, %i4
stop = (*routine)( table_entry, routine_arg );
40013468: 90 10 00 1d mov %i5, %o0
4001346c: 9f c6 00 00 call %i0
40013470: 92 10 00 19 mov %i1, %o1
++table_entry;
40013474: ba 07 60 08 add %i5, 8, %i5
while ( table_entry->type && !stop ) {
40013478: c2 07 40 00 ld [ %i5 ], %g1
4001347c: 80 a0 60 00 cmp %g1, 0
40013480: 12 bf ff f7 bne 4001345c <rtems_filesystem_iterate+0x1c>
40013484: b8 10 00 08 mov %o0, %i4
if ( !stop ) {
40013488: b8 8a 20 ff andcc %o0, 0xff, %i4
4001348c: 12 80 00 17 bne 400134e8 <rtems_filesystem_iterate+0xa8>
<== ALWAYS TAKEN
40013490: 01 00 00 00 nop
rtems_libio_lock();
40013494: 7f ff d0 22 call 4000751c <rtems_libio_lock>
<== NOT EXECUTED
40013498: 37 10 00 94 sethi %hi(0x40025000), %i3
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
4001349c: fa 06 e2 d4 ld [ %i3 + 0x2d4 ], %i5 ! 400252d4 <filesystem_chain>
<== NOT EXECUTED
400134a0: b6 16 e2 d4 or %i3, 0x2d4, %i3
<== NOT EXECUTED
for (
400134a4: b6 06 e0 04 add %i3, 4, %i3
<== NOT EXECUTED
400134a8: 80 a7 40 1b cmp %i5, %i3
<== NOT EXECUTED
400134ac: 12 80 00 06 bne 400134c4 <rtems_filesystem_iterate+0x84>
<== NOT EXECUTED
400134b0: b8 10 20 00 clr %i4
<== NOT EXECUTED
400134b4: 30 80 00 0b b,a 400134e0 <rtems_filesystem_iterate+0xa0>
<== NOT EXECUTED
!rtems_chain_is_tail( chain, node ) && !stop;
400134b8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
400134bc: 12 80 00 09 bne 400134e0 <rtems_filesystem_iterate+0xa0>
<== NOT EXECUTED
400134c0: 01 00 00 00 nop
<== NOT EXECUTED
stop = (*routine)( &fsn->entry, routine_arg );
400134c4: 90 07 60 08 add %i5, 8, %o0
<== NOT EXECUTED
400134c8: 9f c6 00 00 call %i0
<== NOT EXECUTED
400134cc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
400134d0: fa 07 40 00 ld [ %i5 ], %i5
<== NOT EXECUTED
for (
400134d4: 80 a7 40 1b cmp %i5, %i3
<== NOT EXECUTED
400134d8: 12 bf ff f8 bne 400134b8 <rtems_filesystem_iterate+0x78>
<== NOT EXECUTED
400134dc: b8 10 00 08 mov %o0, %i4
<== NOT EXECUTED
rtems_libio_unlock();
400134e0: 7f ff d0 14 call 40007530 <rtems_libio_unlock>
<== NOT EXECUTED
400134e4: b8 0f 20 ff and %i4, 0xff, %i4
<== NOT EXECUTED
}
400134e8: 81 c7 e0 08 ret
400134ec: 91 e8 00 1c restore %g0, %i4, %o0
40008e14 <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;
40008e14: da 02 60 08 ld [ %o1 + 8 ], %o5
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40008e18: c8 02 60 0c ld [ %o1 + 0xc ], %g4
<== NOT EXECUTED
dst->handlers = src->handlers;
40008e1c: c6 02 60 10 ld [ %o1 + 0x10 ], %g3
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40008e20: c2 02 60 14 ld [ %o1 + 0x14 ], %g1
<== NOT EXECUTED
40008e24: c2 22 20 14 st %g1, [ %o0 + 0x14 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
40008e28: da 22 20 08 st %o5, [ %o0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40008e2c: c8 22 20 0c st %g4, [ %o0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40008e30: c6 22 20 10 st %g3, [ %o0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008e34: 91 d0 20 09 ta 9
<== NOT EXECUTED
&loc->mt_entry->location_chain,
40008e38: c6 02 20 14 ld [ %o0 + 0x14 ], %g3
<== NOT EXECUTED
old_last = tail->previous;
40008e3c: c8 00 e0 1c ld [ %g3 + 0x1c ], %g4
<== NOT EXECUTED
return &the_chain->Tail.Node;
40008e40: 9a 00 e0 18 add %g3, 0x18, %o5
<== NOT EXECUTED
the_node->next = tail;
40008e44: da 22 00 00 st %o5, [ %o0 ]
<== NOT EXECUTED
tail->previous = the_node;
40008e48: d0 20 e0 1c st %o0, [ %g3 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40008e4c: d0 21 00 00 st %o0, [ %g4 ]
<== NOT EXECUTED
the_node->previous = old_last;
40008e50: c8 22 20 04 st %g4, [ %o0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008e54: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008e58: 01 00 00 00 nop
rtems_chain_initialize_node(&dst->mt_entry_node);
rtems_filesystem_location_add_to_mt_entry(dst);
return dst;
}
40008e5c: 81 c3 e0 08 retl
40008e60: 01 00 00 00 nop
400091e8 <rtems_filesystem_location_copy_and_detach>:
{
400091e8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
dst->node_access = src->node_access;
400091ec: c8 06 60 08 ld [ %i1 + 8 ], %g4
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
400091f0: c6 06 60 0c ld [ %i1 + 0xc ], %g3
<== NOT EXECUTED
dst->handlers = src->handlers;
400091f4: c4 06 60 10 ld [ %i1 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
400091f8: c2 06 60 14 ld [ %i1 + 0x14 ], %g1
<== NOT EXECUTED
400091fc: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
40009200: c8 26 20 08 st %g4, [ %i0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40009204: c6 26 20 0c st %g3, [ %i0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40009208: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000920c: 91 d0 20 09 ta 9
<== NOT EXECUTED
&loc->mt_entry->location_chain,
40009210: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
40009214: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40009218: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
4000921c: c8 26 00 00 st %g4, [ %i0 ]
<== NOT EXECUTED
tail->previous = the_node;
40009220: f0 20 a0 1c st %i0, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40009224: f0 20 c0 00 st %i0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40009228: c6 26 20 04 st %g3, [ %i0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000922c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009230: 01 00 00 00 nop
rtems_filesystem_location_remove_from_mt_entry(detach);
40009234: 7f ff ff cc call 40009164 <rtems_filesystem_location_remove_from_mt_entry>
40009238: 90 10 00 19 mov %i1, %o0
dst->node_access = src->node_access;
4000923c: 03 10 00 94 sethi %hi(0x40025000), %g1
<== NOT EXECUTED
40009240: 82 10 61 2c or %g1, 0x12c, %g1 ! 4002512c <rtems_filesystem_global_location_null>
<== NOT EXECUTED
40009244: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
40009248: c4 26 60 08 st %g2, [ %i1 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
4000924c: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
40009250: c4 26 60 0c st %g2, [ %i1 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40009254: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40009258: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
4000925c: c2 26 60 14 st %g1, [ %i1 + 0x14 ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40009260: c4 26 60 10 st %g2, [ %i1 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40009264: 91 d0 20 09 ta 9
<== NOT EXECUTED
40009268: c4 06 60 14 ld [ %i1 + 0x14 ], %g2
old_last = tail->previous;
4000926c: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
return &the_chain->Tail.Node;
40009270: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40009274: c8 26 40 00 st %g4, [ %i1 ]
<== NOT EXECUTED
tail->previous = the_node;
40009278: f2 20 a0 1c st %i1, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
4000927c: f2 20 c0 00 st %i1, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40009280: c6 26 60 04 st %g3, [ %i1 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40009284: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40009288: 01 00 00 00 nop
}
4000928c: 81 c7 e0 08 ret
40009290: 81 e8 00 00 restore
40008e64 <rtems_filesystem_location_detach>:
void rtems_filesystem_location_detach(
rtems_filesystem_location_info_t *detach
)
{
40008e64: 9d e3 bf a0 save %sp, -96, %sp
rtems_filesystem_location_free(detach);
40008e68: 40 00 29 0e call 400132a0 <rtems_filesystem_location_free>
40008e6c: 90 10 00 18 mov %i0, %o0
dst->node_access = src->node_access;
40008e70: 03 10 00 94 sethi %hi(0x40025000), %g1
<== NOT EXECUTED
40008e74: 82 10 61 2c or %g1, 0x12c, %g1 ! 4002512c <rtems_filesystem_global_location_null>
<== NOT EXECUTED
40008e78: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
40008e7c: c4 26 20 08 st %g2, [ %i0 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
40008e80: c4 00 60 0c ld [ %g1 + 0xc ], %g2
<== NOT EXECUTED
40008e84: c4 26 20 0c st %g2, [ %i0 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40008e88: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
40008e8c: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
40008e90: c2 26 20 14 st %g1, [ %i0 + 0x14 ]
<== NOT EXECUTED
dst->handlers = src->handlers;
40008e94: c4 26 20 10 st %g2, [ %i0 + 0x10 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008e98: 91 d0 20 09 ta 9
<== NOT EXECUTED
40008e9c: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
old_last = tail->previous;
40008ea0: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
<== NOT EXECUTED
return &the_chain->Tail.Node;
40008ea4: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
the_node->next = tail;
40008ea8: c8 26 00 00 st %g4, [ %i0 ]
<== NOT EXECUTED
tail->previous = the_node;
40008eac: f0 20 a0 1c st %i0, [ %g2 + 0x1c ]
<== NOT EXECUTED
old_last->next = the_node;
40008eb0: f0 20 c0 00 st %i0, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
40008eb4: c6 26 20 04 st %g3, [ %i0 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008eb8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008ebc: 01 00 00 00 nop
rtems_filesystem_location_initialize_to_null(detach);
}
40008ec0: 81 c7 e0 08 ret
40008ec4: 81 e8 00 00 restore
40009164 <rtems_filesystem_location_remove_from_mt_entry>:
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40009164: 91 d0 20 09 ta 9
<== NOT EXECUTED
previous = the_node->previous;
40009168: c6 02 20 04 ld [ %o0 + 4 ], %g3
next = the_node->next;
4000916c: c8 02 00 00 ld [ %o0 ], %g4
next->previous = previous;
40009170: c6 21 20 04 st %g3, [ %g4 + 4 ]
do_unmount = rtems_filesystem_is_ready_for_unmount(loc->mt_entry);
40009174: c4 02 20 14 ld [ %o0 + 0x14 ], %g2
previous->next = next;
40009178: c8 20 c0 00 st %g4, [ %g3 ]
4000917c: c6 08 a0 28 ldub [ %g2 + 0x28 ], %g3
40009180: 80 a0 e0 00 cmp %g3, 0
40009184: 12 80 00 07 bne 400091a0 <rtems_filesystem_location_remove_from_mt_entry+0x3c>
40009188: 01 00 00 00 nop
&& rtems_chain_has_only_one_node( &mt_entry->location_chain )
4000918c: c8 00 a0 14 ld [ %g2 + 0x14 ], %g4
40009190: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
40009194: 80 a1 00 03 cmp %g4, %g3
40009198: 22 80 00 06 be,a 400091b0 <rtems_filesystem_location_remove_from_mt_entry+0x4c>
4000919c: c6 00 a0 24 ld [ %g2 + 0x24 ], %g3
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400091a0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400091a4: 01 00 00 00 nop
}
400091a8: 81 c3 e0 08 retl
400091ac: 01 00 00 00 nop
&& mt_entry->mt_fs_root->reference_count == 1;
400091b0: c6 00 e0 18 ld [ %g3 + 0x18 ], %g3
400091b4: 80 a0 e0 01 cmp %g3, 1
400091b8: 12 bf ff fa bne 400091a0 <rtems_filesystem_location_remove_from_mt_entry+0x3c>
<== ALWAYS TAKEN
400091bc: 86 00 a0 14 add %g2, 0x14, %g3
return &the_chain->Tail.Node;
400091c0: 88 00 a0 18 add %g2, 0x18, %g4
<== NOT EXECUTED
head->previous = NULL;
400091c4: c0 20 a0 18 clr [ %g2 + 0x18 ]
<== NOT EXECUTED
head->next = tail;
400091c8: c8 20 a0 14 st %g4, [ %g2 + 0x14 ]
<== NOT EXECUTED
tail->previous = head;
400091cc: c6 20 a0 1c st %g3, [ %g2 + 0x1c ]
<== NOT EXECUTED
400091d0: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400091d4: 01 00 00 00 nop
<== NOT EXECUTED
rtems_filesystem_do_unmount(loc->mt_entry);
400091d8: d0 02 20 14 ld [ %o0 + 0x14 ], %o0
<== NOT EXECUTED
400091dc: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
400091e0: 7f ff ff 3a call 40008ec8 <rtems_filesystem_do_unmount>
<== NOT EXECUTED
400091e4: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40009294 <rtems_filesystem_location_transform_to_global>:
{
40009294: 9d e3 bf 98 save %sp, -104, %sp
rtems_filesystem_global_location_t *global_loc = malloc(sizeof(*global_loc));
40009298: 7f ff f9 a6 call 40007930 <malloc>
4000929c: 90 10 20 24 mov 0x24, %o0
if (global_loc != NULL) {
400092a0: ba 92 20 00 orcc %o0, 0, %i5
400092a4: 02 80 00 1c be 40009314 <rtems_filesystem_location_transform_to_global+0x80>
<== NEVER TAKEN
400092a8: b8 10 20 01 mov 1, %i4
dst->node_access = src->node_access;
400092ac: c8 06 20 08 ld [ %i0 + 8 ], %g4
dst->node_access_2 = src->node_access_2;
400092b0: c6 06 20 0c ld [ %i0 + 0xc ], %g3
dst->handlers = src->handlers;
400092b4: c4 06 20 10 ld [ %i0 + 0x10 ], %g2
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
400092b8: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
<== NOT EXECUTED
global_loc->deferred_released_next = NULL;
400092bc: c0 27 60 1c clr [ %i5 + 0x1c ]
<== NOT EXECUTED
global_loc->reference_count = 1;
400092c0: f8 27 60 18 st %i4, [ %i5 + 0x18 ]
<== NOT EXECUTED
global_loc->deferred_released_count = 0;
400092c4: c0 27 60 20 clr [ %i5 + 0x20 ]
<== NOT EXECUTED
dst->node_access = src->node_access;
400092c8: c8 27 60 08 st %g4, [ %i5 + 8 ]
<== NOT EXECUTED
dst->node_access_2 = src->node_access_2;
400092cc: c6 27 60 0c st %g3, [ %i5 + 0xc ]
<== NOT EXECUTED
dst->handlers = src->handlers;
400092d0: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
<== NOT EXECUTED
dst->mt_entry = src->mt_entry;
400092d4: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400092d8: 91 d0 20 09 ta 9
<== NOT EXECUTED
400092dc: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
old_last = tail->previous;
400092e0: c6 00 a0 1c ld [ %g2 + 0x1c ], %g3
return &the_chain->Tail.Node;
400092e4: 88 00 a0 18 add %g2, 0x18, %g4
the_node->next = tail;
400092e8: c8 27 40 00 st %g4, [ %i5 ]
tail->previous = the_node;
400092ec: fa 20 a0 1c st %i5, [ %g2 + 0x1c ]
old_last->next = the_node;
400092f0: fa 20 c0 00 st %i5, [ %g3 ]
<== NOT EXECUTED
the_node->previous = old_last;
400092f4: c6 27 60 04 st %g3, [ %i5 + 4 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400092f8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400092fc: 01 00 00 00 nop
rtems_filesystem_location_remove_from_mt_entry(loc);
40009300: 90 10 00 18 mov %i0, %o0
40009304: 7f ff ff 98 call 40009164 <rtems_filesystem_location_remove_from_mt_entry>
40009308: b0 10 00 1d mov %i5, %i0
}
4000930c: 81 c7 e0 08 ret
40009310: 81 e8 00 00 restore
rtems_filesystem_location_free(loc);
40009314: 40 00 27 e3 call 400132a0 <rtems_filesystem_location_free>
<== NOT EXECUTED
40009318: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
return rtems_filesystem_global_location_obtain( &global_loc );
4000931c: 90 07 bf fc add %fp, -4, %o0
<== NOT EXECUTED
40009320: 7f ff ff 33 call 40008fec <rtems_filesystem_global_location_obtain>
<== NOT EXECUTED
40009324: c0 27 bf fc clr [ %fp + -4 ]
<== NOT EXECUTED
errno = ENOMEM;
40009328: 40 00 2e e8 call 40014ec8 <__errno>
<== NOT EXECUTED
4000932c: ba 10 00 08 mov %o0, %i5
<== NOT EXECUTED
40009330: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40009334: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40009338: 81 c7 e0 08 ret
<== NOT EXECUTED
4000933c: 91 e8 00 1d restore %g0, %i5, %o0
<== NOT EXECUTED
4000799c <rtems_filesystem_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
4000799c: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
400079a0: 40 00 01 e3 call 4000812c <rtems_current_user_env_get>
400079a4: 01 00 00 00 nop
400079a8: d6 02 20 08 ld [ %o0 + 8 ], %o3
400079ac: 96 2e c0 0b andn %i3, %o3, %o3
switch (mode & S_IFMT) {
400079b0: 03 00 00 3c sethi %hi(0xf000), %g1
400079b4: 05 00 00 10 sethi %hi(0x4000), %g2
400079b8: 82 0a c0 01 and %o3, %g1, %g1
400079bc: 80 a0 40 02 cmp %g1, %g2
400079c0: 22 80 00 0c be,a 400079f0 <rtems_filesystem_mknod+0x54>
400079c4: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
400079c8: 08 80 00 14 bleu 40007a18 <rtems_filesystem_mknod+0x7c>
400079cc: 05 00 00 04 sethi %hi(0x1000), %g2
400079d0: 05 00 00 18 sethi %hi(0x6000), %g2
400079d4: 80 a0 40 02 cmp %g1, %g2
400079d8: 02 80 00 05 be 400079ec <rtems_filesystem_mknod+0x50>
400079dc: 05 00 00 20 sethi %hi(0x8000), %g2
400079e0: 80 a0 40 02 cmp %g1, %g2
400079e4: 12 80 00 13 bne 40007a30 <rtems_filesystem_mknod+0x94>
<== NEVER TAKEN
400079e8: 01 00 00 00 nop
rv = -1;
break;
}
if ( rv == 0 ) {
const rtems_filesystem_operations_table *ops = parentloc->mt_entry->ops;
400079ec: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
rv = (*ops->mknod_h)( parentloc, name, namelen, mode, dev );
400079f0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
400079f4: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
400079f8: 98 10 00 1c mov %i4, %o4
400079fc: 9a 10 00 1d mov %i5, %o5
40007a00: 94 10 00 1a mov %i2, %o2
40007a04: 92 10 00 19 mov %i1, %o1
40007a08: 9f c0 40 00 call %g1
40007a0c: 90 10 00 18 mov %i0, %o0
40007a10: 81 c7 e0 08 ret
40007a14: 91 e8 00 08 restore %g0, %o0, %o0
switch (mode & S_IFMT) {
40007a18: 80 a0 40 02 cmp %g1, %g2
40007a1c: 02 bf ff f4 be 400079ec <rtems_filesystem_mknod+0x50>
40007a20: 05 00 00 08 sethi %hi(0x2000), %g2
40007a24: 80 a0 40 02 cmp %g1, %g2
40007a28: 22 bf ff f2 be,a 400079f0 <rtems_filesystem_mknod+0x54>
<== ALWAYS TAKEN
40007a2c: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
errno = EINVAL;
40007a30: 40 00 35 26 call 40014ec8 <__errno>
<== NOT EXECUTED
40007a34: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40007a38: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40007a3c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
return rv;
}
40007a40: 81 c7 e0 08 ret
<== NOT EXECUTED
40007a44: 81 e8 00 00 restore
<== NOT EXECUTED
400234f0 <rtems_filesystem_null_handlers>:
400234f0: 40 00 95 24 40 00 45 1c 40 01 2f dc 40 01 2f f8 @..$@.E.@./.@./.
40023500: 40 01 2f 60 40 01 2f c0 40 00 95 2c 40 00 45 34 @./`@./.@..,@.E4
40023510: 40 01 2f 20 40 01 2f 20 40 00 45 24 40 00 46 b0 @./ @./ @.E$@.F.
40023520: 40 00 45 50 40 00 46 b8 40 00 47 50 40 00 46 8c @.EP@.F.@.GP@.F.
4000778c <rtems_heap_allocate_aligned_with_boundary>:
void *rtems_heap_allocate_aligned_with_boundary(
size_t size,
uintptr_t alignment,
uintptr_t boundary
)
{
4000778c: 9d e3 bf a0 save %sp, -96, %sp
40007790: 03 10 00 9b sethi %hi(0x40026c00), %g1
40007794: c2 00 60 7c ld [ %g1 + 0x7c ], %g1 ! 40026c7c <_System_state_Current>
Heap_Control *heap = RTEMS_Malloc_Heap;
40007798: 05 10 00 94 sethi %hi(0x40025000), %g2
if ( _System_state_Is_up( state ) ) {
4000779c: 80 a0 60 02 cmp %g1, 2
400077a0: 02 80 00 21 be 40007824 <rtems_heap_allocate_aligned_with_boundary+0x98>
400077a4: f8 00 a0 7c ld [ %g2 + 0x7c ], %i4
} else if ( _System_state_Is_before_multitasking( state ) ) {
400077a8: 80 a0 60 01 cmp %g1, 1
400077ac: 02 80 00 22 be 40007834 <rtems_heap_allocate_aligned_with_boundary+0xa8>
400077b0: 96 10 00 1a mov %i2, %o3
boundary
);
_RTEMS_Unlock_allocator();
break;
case MALLOC_SYSTEM_STATE_NO_PROTECTION:
p = _Heap_Allocate_aligned_with_boundary(
400077b4: 94 10 00 19 mov %i1, %o2
400077b8: 92 10 00 18 mov %i0, %o1
400077bc: 40 00 09 51 call 40009d00 <_Heap_Allocate_aligned_with_boundary>
400077c0: 90 10 00 1c mov %i4, %o0
400077c4: 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 ) {
400077c8: 80 a7 60 00 cmp %i5, 0
400077cc: 12 80 00 0b bne 400077f8 <rtems_heap_allocate_aligned_with_boundary+0x6c>
400077d0: 80 a6 60 00 cmp %i1, 0
400077d4: 12 80 00 09 bne 400077f8 <rtems_heap_allocate_aligned_with_boundary+0x6c>
<== NEVER TAKEN
400077d8: 80 a6 a0 00 cmp %i2, 0
400077dc: 12 80 00 23 bne 40007868 <rtems_heap_allocate_aligned_with_boundary+0xdc>
<== NEVER TAKEN
400077e0: 03 10 00 8a sethi %hi(0x40022800), %g1
p = (*rtems_malloc_extend_handler)( heap, size );
400077e4: c2 00 63 9c ld [ %g1 + 0x39c ], %g1 ! 40022b9c <rtems_malloc_extend_handler>
400077e8: 92 10 00 18 mov %i0, %o1
400077ec: 9f c0 40 00 call %g1
400077f0: 90 10 00 1c mov %i4, %o0
400077f4: ba 10 00 08 mov %o0, %i5
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( p != NULL && rtems_malloc_dirty_helper != NULL )
400077f8: 80 a7 60 00 cmp %i5, 0
400077fc: 02 80 00 1b be 40007868 <rtems_heap_allocate_aligned_with_boundary+0xdc>
40007800: 03 10 00 95 sethi %hi(0x40025400), %g1
40007804: c2 00 62 80 ld [ %g1 + 0x280 ], %g1 ! 40025680 <rtems_malloc_dirty_helper>
40007808: 80 a0 60 00 cmp %g1, 0
4000780c: 02 80 00 04 be 4000781c <rtems_heap_allocate_aligned_with_boundary+0x90>
<== ALWAYS TAKEN
40007810: 92 10 00 18 mov %i0, %o1
(*rtems_malloc_dirty_helper)( p, size );
40007814: 9f c0 40 00 call %g1
<== NOT EXECUTED
40007818: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
return p;
}
4000781c: 81 c7 e0 08 ret
40007820: 91 e8 00 1d restore %g0, %i5, %o0
40007824: c2 01 a0 18 ld [ %g6 + 0x18 ], %g1
if ( _Thread_Dispatch_is_enabled() ) {
40007828: 80 a0 60 00 cmp %g1, 0
4000782c: 32 80 00 10 bne,a 4000786c <rtems_heap_allocate_aligned_with_boundary+0xe0>
<== NEVER TAKEN
40007830: ba 10 20 00 clr %i5
<== NOT EXECUTED
_RTEMS_Lock_allocator();
40007834: 40 00 08 bd call 40009b28 <_RTEMS_Lock_allocator>
40007838: 01 00 00 00 nop
_Malloc_Process_deferred_frees();
4000783c: 7f ff ff bb call 40007728 <_Malloc_Process_deferred_frees>
40007840: 01 00 00 00 nop
p = _Heap_Allocate_aligned_with_boundary(
40007844: 96 10 00 1a mov %i2, %o3
40007848: 94 10 00 19 mov %i1, %o2
4000784c: 92 10 00 18 mov %i0, %o1
40007850: 40 00 09 2c call 40009d00 <_Heap_Allocate_aligned_with_boundary>
40007854: 90 10 00 1c mov %i4, %o0
_RTEMS_Unlock_allocator();
40007858: 40 00 08 b9 call 40009b3c <_RTEMS_Unlock_allocator>
4000785c: ba 10 00 08 mov %o0, %i5
break;
40007860: 10 bf ff db b 400077cc <rtems_heap_allocate_aligned_with_boundary+0x40>
40007864: 80 a7 60 00 cmp %i5, 0
return NULL;
40007868: ba 10 20 00 clr %i5
}
4000786c: 81 c7 e0 08 ret
40007870: 91 e8 00 1d restore %g0, %i5, %o0
40007578 <rtems_libio_allocate>:
return fcntl_flags;
}
rtems_libio_t *rtems_libio_allocate( void )
{
40007578: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
rtems_libio_lock();
4000757c: 7f ff ff e8 call 4000751c <rtems_libio_lock>
40007580: 01 00 00 00 nop
iop = rtems_libio_iop_free_head;
40007584: 03 10 00 9b sethi %hi(0x40026c00), %g1
40007588: f0 00 60 20 ld [ %g1 + 0x20 ], %i0 ! 40026c20 <rtems_libio_iop_free_head>
if ( iop != NULL ) {
4000758c: 80 a6 20 00 cmp %i0, 0
40007590: 02 80 00 06 be 400075a8 <rtems_libio_allocate+0x30>
<== NEVER TAKEN
40007594: 86 10 60 20 or %g1, 0x20, %g3
void *next;
next = iop->data1;
40007598: c4 06 20 28 ld [ %i0 + 0x28 ], %g2
rtems_libio_iop_free_head = next;
if ( next == NULL ) {
4000759c: 80 a0 a0 00 cmp %g2, 0
400075a0: 02 80 00 06 be 400075b8 <rtems_libio_allocate+0x40>
400075a4: c4 20 60 20 st %g2, [ %g1 + 0x20 ]
rtems_libio_iop_free_tail = &rtems_libio_iop_free_head;
}
}
rtems_libio_unlock();
400075a8: 7f ff ff e2 call 40007530 <rtems_libio_unlock>
400075ac: 01 00 00 00 nop
return iop;
}
400075b0: 81 c7 e0 08 ret
400075b4: 81 e8 00 00 restore
rtems_libio_iop_free_tail = &rtems_libio_iop_free_head;
400075b8: 03 10 00 94 sethi %hi(0x40025000), %g1
rtems_libio_unlock();
400075bc: 7f ff ff dd call 40007530 <rtems_libio_unlock>
400075c0: c6 20 60 ac st %g3, [ %g1 + 0xac ] ! 400250ac <rtems_libio_iop_free_tail>
}
400075c4: 81 c7 e0 08 ret
400075c8: 81 e8 00 00 restore
400133ec <rtems_libio_exit>:
#include <unistd.h>
#include <rtems/libio.h>
void rtems_libio_exit(void)
{
400133ec: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
(void)close(0);
400133f0: 7f ff cf 04 call 40007000 <close>
<== NOT EXECUTED
400133f4: 90 10 20 00 clr %o0
<== NOT EXECUTED
(void)close(1);
(void)close(2);
400133f8: b0 10 20 02 mov 2, %i0
<== NOT EXECUTED
(void)close(1);
400133fc: 7f ff cf 01 call 40007000 <close>
<== NOT EXECUTED
40013400: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
(void)close(2);
40013404: 7f ff ce ff call 40007000 <close>
<== NOT EXECUTED
40013408: 81 e8 00 00 restore
<== NOT EXECUTED
40008158 <rtems_libio_free_user_env>:
if (!uses_global_env) {
40008158: 03 10 00 94 sethi %hi(0x40025000), %g1
<== NOT EXECUTED
4000815c: 82 10 60 e4 or %g1, 0xe4, %g1 ! 400250e4 <rtems_global_user_env>
<== NOT EXECUTED
40008160: 80 a0 40 08 cmp %g1, %o0
<== NOT EXECUTED
40008164: 02 80 00 05 be 40008178 <rtems_libio_free_user_env+0x20>
<== NOT EXECUTED
40008168: 01 00 00 00 nop
<== NOT EXECUTED
4000816c: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40008170: 7f ff ff e6 call 40008108 <rtems_libio_free_user_env.part.1>
<== NOT EXECUTED
40008174: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
}
}
40008178: 81 c3 e0 08 retl
<== NOT EXECUTED
4000817c: 01 00 00 00 nop
<== NOT EXECUTED
40007e48 <rtems_libio_post_driver>:
/*
* This is a replaceable stub which opens the console, if present.
*/
void rtems_libio_post_driver(void)
{
40007e48: 9d e3 bf a0 save %sp, -96, %sp
/*
* Attempt to open /dev/console.
*/
if ( open( CONSOLE_DEVICE_NAME, O_RDONLY, 0 ) != STDIN_FILENO ) {
40007e4c: 94 10 20 00 clr %o2
40007e50: 92 10 20 00 clr %o1
40007e54: 3b 10 00 8c sethi %hi(0x40023000), %i5
40007e58: 40 00 00 1a call 40007ec0 <open>
40007e5c: 90 17 63 00 or %i5, 0x300, %o0 ! 40023300 <IMFS_node_control_sym_link+0x18>
40007e60: 80 a2 20 00 cmp %o0, 0
40007e64: 02 80 00 04 be 40007e74 <rtems_libio_post_driver+0x2c>
40007e68: 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);
}
40007e6c: 81 c7 e0 08 ret
40007e70: 81 e8 00 00 restore
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDOUT_FILENO ) {
40007e74: 92 10 20 01 mov 1, %o1
40007e78: 40 00 00 12 call 40007ec0 <open>
40007e7c: 90 17 63 00 or %i5, 0x300, %o0
40007e80: 80 a2 20 01 cmp %o0, 1
40007e84: 12 80 00 0a bne 40007eac <rtems_libio_post_driver+0x64>
<== NEVER TAKEN
40007e88: 94 10 20 00 clr %o2
if ( open( CONSOLE_DEVICE_NAME, O_WRONLY, 0 ) != STDERR_FILENO ) {
40007e8c: 92 10 20 01 mov 1, %o1
40007e90: 40 00 00 0c call 40007ec0 <open>
40007e94: 90 17 63 00 or %i5, 0x300, %o0
40007e98: 80 a2 20 02 cmp %o0, 2
40007e9c: 12 80 00 06 bne 40007eb4 <rtems_libio_post_driver+0x6c>
<== NEVER TAKEN
40007ea0: 31 10 00 4c sethi %hi(0x40013000), %i0
atexit(rtems_libio_exit);
40007ea4: 40 00 34 02 call 40014eac <atexit>
<== NOT EXECUTED
40007ea8: 91 ee 23 ec restore %i0, 0x3ec, %o0
_Internal_error( INTERNAL_ERROR_LIBIO_STDOUT_FD_OPEN_FAILED );
40007eac: 40 00 09 bd call 4000a5a0 <_Internal_error>
<== NOT EXECUTED
40007eb0: 90 10 20 24 mov 0x24, %o0
<== NOT EXECUTED
_Internal_error( INTERNAL_ERROR_LIBIO_STDERR_FD_OPEN_FAILED );
40007eb4: 40 00 09 bb call 4000a5a0 <_Internal_error>
<== NOT EXECUTED
40007eb8: 90 10 20 25 mov 0x25, %o0
<== NOT EXECUTED
40007ebc: 01 00 00 00 nop
<== NOT EXECUTED
40012d80 <rtems_libio_set_private_env>:
rtems_status_code rtems_libio_set_private_env(void)
{
40012d80: 9d e3 bf a0 save %sp, -96, %sp
void *ptr = pthread_getspecific(rtems_current_user_env_key);
40012d84: 39 10 01 19 sethi %hi(0x40046400), %i4
40012d88: 40 00 05 93 call 400143d4 <pthread_getspecific>
40012d8c: d0 07 22 94 ld [ %i4 + 0x294 ], %o0 ! 40046694 <rtems_current_user_env_key>
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_user_env_t *old_env = rtems_current_user_env;
bool uses_global_env = old_env == &rtems_global_user_env;
if (uses_global_env) {
40012d90: 3b 10 01 11 sethi %hi(0x40044400), %i5
40012d94: ba 17 61 e4 or %i5, 0x1e4, %i5 ! 400445e4 <rtems_global_user_env>
40012d98: 80 a2 00 1d cmp %o0, %i5
40012d9c: 02 80 00 04 be 40012dac <rtems_libio_set_private_env+0x2c>
<== NEVER TAKEN
40012da0: 80 a2 20 00 cmp %o0, 0
40012da4: 12 80 00 30 bne 40012e64 <rtems_libio_set_private_env+0xe4>
40012da8: b0 10 20 00 clr %i0
Thread_Life_state life_state =
40012dac: 40 00 1a f0 call 4001996c <_Thread_Set_life_protection>
40012db0: 90 10 20 01 mov 1, %o0
_Thread_Set_life_protection(THREAD_LIFE_PROTECTED);
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
40012db4: 92 10 20 48 mov 0x48, %o1
Thread_Life_state life_state =
40012db8: b4 10 00 08 mov %o0, %i2
if (sc != RTEMS_SUCCESSFUL) {
rtems_libio_free_user_env(new_env);
}
} else {
sc = RTEMS_NO_MEMORY;
40012dbc: b0 10 20 1a mov 0x1a, %i0
rtems_user_env_t *new_env = calloc(1, sizeof(*new_env));
40012dc0: 7f ff fb 7b call 40011bac <calloc>
40012dc4: 90 10 20 01 mov 1, %o0
if (new_env != NULL) {
40012dc8: 80 a2 20 00 cmp %o0, 0
40012dcc: 02 80 00 24 be 40012e5c <rtems_libio_set_private_env+0xdc>
<== NEVER TAKEN
40012dd0: b6 10 00 08 mov %o0, %i3
*new_env = *old_env;
40012dd4: 94 10 20 48 mov 0x48, %o2
40012dd8: 40 00 26 b4 call 4001c8a8 <memcpy>
40012ddc: 92 10 00 1d mov %i5, %o1
rtems_filesystem_global_location_obtain(&old_env->root_directory);
40012de0: 40 00 03 63 call 40013b6c <rtems_filesystem_global_location_obtain>
40012de4: 90 07 60 04 add %i5, 4, %o0
new_env->root_directory =
40012de8: d0 26 e0 04 st %o0, [ %i3 + 4 ]
rtems_filesystem_global_location_obtain(&old_env->current_directory);
40012dec: 40 00 03 60 call 40013b6c <rtems_filesystem_global_location_obtain>
40012df0: 90 10 00 1d mov %i5, %o0
if (
40012df4: c2 06 e0 04 ld [ %i3 + 4 ], %g1
new_env->current_directory =
40012df8: d0 26 c0 00 st %o0, [ %i3 ]
if (
40012dfc: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
40012e00: 03 10 00 87 sethi %hi(0x40021c00), %g1
40012e04: 82 10 63 c4 or %g1, 0x3c4, %g1 ! 40021fc4 <rtems_filesystem_null_handlers>
40012e08: 80 a0 80 01 cmp %g2, %g1
40012e0c: 22 80 00 0f be,a 40012e48 <rtems_libio_set_private_env+0xc8>
40012e10: b0 10 20 0d mov 0xd, %i0
&& !rtems_filesystem_global_location_is_null(new_env->current_directory)
40012e14: c4 02 20 10 ld [ %o0 + 0x10 ], %g2
40012e18: 80 a0 80 01 cmp %g2, %g1
40012e1c: 02 80 00 0a be 40012e44 <rtems_libio_set_private_env+0xc4>
<== NEVER TAKEN
40012e20: d0 07 22 94 ld [ %i4 + 0x294 ], %o0
int eno = pthread_setspecific(
40012e24: 92 10 00 1b mov %i3, %o1
40012e28: 40 00 05 e6 call 400145c0 <pthread_setspecific>
40012e2c: b0 10 20 00 clr %i0
if (eno == 0) {
40012e30: 80 a2 20 00 cmp %o0, 0
40012e34: 02 80 00 0a be 40012e5c <rtems_libio_set_private_env+0xdc>
<== ALWAYS TAKEN
40012e38: 01 00 00 00 nop
40012e3c: 10 80 00 03 b 40012e48 <rtems_libio_set_private_env+0xc8>
<== NOT EXECUTED
40012e40: b0 10 20 05 mov 5, %i0 ! 5 <_TLS_Alignment+0x4>
<== NOT EXECUTED
sc = RTEMS_UNSATISFIED;
40012e44: b0 10 20 0d mov 0xd, %i0
<== NOT EXECUTED
if (!uses_global_env) {
40012e48: 80 a6 c0 1d cmp %i3, %i5
40012e4c: 02 80 00 04 be 40012e5c <rtems_libio_set_private_env+0xdc>
<== NEVER TAKEN
40012e50: 01 00 00 00 nop
40012e54: 7f ff ff ad call 40012d08 <rtems_libio_free_user_env.part.1>
40012e58: 90 10 00 1b mov %i3, %o0
}
_Thread_Set_life_protection(life_state);
40012e5c: 40 00 1a c4 call 4001996c <_Thread_Set_life_protection>
40012e60: 90 10 00 1a mov %i2, %o0
}
return sc;
}
40012e64: 81 c7 e0 08 ret
40012e68: 81 e8 00 00 restore
40006178 <rtems_libio_to_fcntl_flags>:
int rtems_libio_to_fcntl_flags( unsigned int flags )
{
int fcntl_flags = 0;
if ( (flags & LIBIO_FLAGS_READ_WRITE) == LIBIO_FLAGS_READ_WRITE ) {
40006178: 84 0a 20 06 and %o0, 6, %g2
4000617c: 80 a0 a0 06 cmp %g2, 6
40006180: 02 80 00 05 be 40006194 <rtems_libio_to_fcntl_flags+0x1c>
<== ALWAYS TAKEN
40006184: 82 10 20 02 mov 2, %g1
fcntl_flags |= O_RDWR;
} else if ( (flags & LIBIO_FLAGS_READ) == LIBIO_FLAGS_READ) {
40006188: 80 8a 20 02 btst 2, %o0
<== NOT EXECUTED
4000618c: 02 80 00 0b be 400061b8 <rtems_libio_to_fcntl_flags+0x40>
<== NOT EXECUTED
40006190: 82 10 20 00 clr %g1
<== NOT EXECUTED
fcntl_flags |= O_RDONLY;
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
fcntl_flags |= O_WRONLY;
}
if ( (flags & LIBIO_FLAGS_NO_DELAY) == LIBIO_FLAGS_NO_DELAY ) {
40006194: 80 8a 20 01 btst 1, %o0
40006198: 02 80 00 04 be 400061a8 <rtems_libio_to_fcntl_flags+0x30>
<== ALWAYS TAKEN
4000619c: 80 8a 22 00 btst 0x200, %o0
fcntl_flags |= O_NONBLOCK;
400061a0: 05 00 00 10 sethi %hi(0x4000), %g2
<== NOT EXECUTED
400061a4: 82 10 40 02 or %g1, %g2, %g1
<== NOT EXECUTED
}
if ( (flags & LIBIO_FLAGS_APPEND) == LIBIO_FLAGS_APPEND ) {
400061a8: 32 80 00 02 bne,a 400061b0 <rtems_libio_to_fcntl_flags+0x38>
<== NEVER TAKEN
400061ac: 82 10 60 08 or %g1, 8, %g1
<== NOT EXECUTED
fcntl_flags |= O_APPEND;
}
return fcntl_flags;
}
400061b0: 81 c3 e0 08 retl
400061b4: 90 10 00 01 mov %g1, %o0
} else if ( (flags & LIBIO_FLAGS_WRITE) == LIBIO_FLAGS_WRITE) {
400061b8: 83 32 20 02 srl %o0, 2, %g1
<== NOT EXECUTED
400061bc: 10 bf ff f6 b 40006194 <rtems_libio_to_fcntl_flags+0x1c>
<== NOT EXECUTED
400061c0: 82 08 60 01 and %g1, 1, %g1
<== NOT EXECUTED
40012e6c <rtems_libio_use_global_env>:
void rtems_libio_use_global_env(void)
{
40012e6c: 9d e3 bf a0 save %sp, -96, %sp
void *ptr = pthread_getspecific(rtems_current_user_env_key);
40012e70: 39 10 01 19 sethi %hi(0x40046400), %i4
40012e74: 40 00 05 58 call 400143d4 <pthread_getspecific>
40012e78: d0 07 22 94 ld [ %i4 + 0x294 ], %o0 ! 40046694 <rtems_current_user_env_key>
rtems_user_env_t *env = rtems_current_user_env;
bool uses_private_env = env != &rtems_global_user_env;
if (uses_private_env) {
40012e7c: 03 10 01 11 sethi %hi(0x40044400), %g1
40012e80: 82 10 61 e4 or %g1, 0x1e4, %g1 ! 400445e4 <rtems_global_user_env>
40012e84: 80 a2 00 01 cmp %o0, %g1
40012e88: 02 80 00 0f be 40012ec4 <rtems_libio_use_global_env+0x58>
<== NEVER TAKEN
40012e8c: ba 10 00 08 mov %o0, %i5
40012e90: 80 a2 20 00 cmp %o0, 0
40012e94: 02 80 00 0c be 40012ec4 <rtems_libio_use_global_env+0x58>
40012e98: 01 00 00 00 nop
Thread_Life_state life_state =
40012e9c: 40 00 1a b4 call 4001996c <_Thread_Set_life_protection>
40012ea0: 90 10 20 01 mov 1, %o0 ! 1 <_TLS_Alignment>
40012ea4: b0 10 00 08 mov %o0, %i0
40012ea8: 7f ff ff 98 call 40012d08 <rtems_libio_free_user_env.part.1>
40012eac: 90 10 00 1d mov %i5, %o0
_Thread_Set_life_protection(THREAD_LIFE_PROTECTED);
rtems_libio_free_user_env(env);
pthread_setspecific(rtems_current_user_env_key, NULL);
40012eb0: d0 07 22 94 ld [ %i4 + 0x294 ], %o0
40012eb4: 40 00 05 c3 call 400145c0 <pthread_setspecific>
40012eb8: 92 10 20 00 clr %o1
_Thread_Set_life_protection(life_state);
40012ebc: 40 00 1a ac call 4001996c <_Thread_Set_life_protection>
<== NOT EXECUTED
40012ec0: 81 e8 00 00 restore
}
}
40012ec4: 81 c7 e0 08 ret
40012ec8: 81 e8 00 00 restore
400076b0 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
400076b0: 9d e3 bf 40 save %sp, -192, %sp
int success = 0;
char *dup_path = strdup(path);
400076b4: 40 00 61 8d call 4001fce8 <strdup>
400076b8: 90 10 00 18 mov %i0, %o0
if (dup_path != NULL) {
400076bc: b8 92 20 00 orcc %o0, 0, %i4
400076c0: 02 80 00 6e be 40007878 <rtems_mkdir+0x1c8>
<== NEVER TAKEN
400076c4: 01 00 00 00 nop
if (p[0] == '/') /* Skip leading '/'. */
400076c8: c2 0f 00 00 ldub [ %i4 ], %g1
400076cc: 83 28 60 18 sll %g1, 0x18, %g1
400076d0: 85 38 60 18 sra %g1, 0x18, %g2
400076d4: 80 a0 a0 2f cmp %g2, 0x2f
400076d8: 12 80 00 05 bne 400076ec <rtems_mkdir+0x3c>
<== NEVER TAKEN
400076dc: ba 10 00 1c mov %i4, %i5
400076e0: c2 0f 20 01 ldub [ %i4 + 1 ], %g1
++p;
400076e4: ba 07 20 01 add %i4, 1, %i5
400076e8: 83 28 60 18 sll %g1, 0x18, %g1
if (p[0] == '\0')
400076ec: 83 38 60 18 sra %g1, 0x18, %g1
400076f0: ba 07 60 01 inc %i5
*p = '/';
400076f4: b6 10 20 00 clr %i3
400076f8: 84 10 20 01 mov 1, %g2
400076fc: b0 10 20 2f mov 0x2f, %i0
} else if (!S_ISDIR(sb.st_mode)) {
40007700: 23 00 00 3c sethi %hi(0xf000), %l1
if (p[0] == '\0')
40007704: 80 a0 60 00 cmp %g1, 0
40007708: 02 80 00 18 be 40007768 <rtems_mkdir+0xb8>
<== NEVER TAKEN
4000770c: 21 00 00 10 sethi %hi(0x4000), %l0
else if (p[0] != '/')
40007710: 80 a0 60 2f cmp %g1, 0x2f
40007714: 12 80 00 0f bne 40007750 <rtems_mkdir+0xa0>
<== ALWAYS TAKEN
40007718: 80 a0 a0 00 cmp %g2, 0
*p = '\0';
4000771c: c0 2f 7f ff clrb [ %i5 + -1 ]
<== NOT EXECUTED
if (first) {
40007720: 12 80 00 5c bne 40007890 <rtems_mkdir+0x1e0>
<== NOT EXECUTED
40007724: f4 0f 40 00 ldub [ %i5 ], %i2
<== NOT EXECUTED
if (last)
40007728: 80 8e a0 ff btst 0xff, %i2
<== NOT EXECUTED
4000772c: 02 80 00 17 be 40007788 <rtems_mkdir+0xd8>
<== NOT EXECUTED
40007730: 92 10 21 ff mov 0x1ff, %o1
<== NOT EXECUTED
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
40007734: 7f ff fc a8 call 400069d4 <mkdir>
<== NOT EXECUTED
40007738: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
4000773c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40007740: 06 80 00 1f bl 400077bc <rtems_mkdir+0x10c>
<== NOT EXECUTED
40007744: b4 10 20 00 clr %i2
<== NOT EXECUTED
*p = '/';
40007748: f0 2f 7f ff stb %i0, [ %i5 + -1 ]
<== NOT EXECUTED
4000774c: 84 10 20 00 clr %g2
<== NOT EXECUTED
40007750: c2 0f 40 00 ldub [ %i5 ], %g1
40007754: 83 28 60 18 sll %g1, 0x18, %g1
if (p[0] == '\0')
40007758: 83 38 60 18 sra %g1, 0x18, %g1
4000775c: 80 a0 60 00 cmp %g1, 0
40007760: 12 bf ff ec bne 40007710 <rtems_mkdir+0x60>
40007764: ba 07 60 01 inc %i5
if (first) {
40007768: 80 a0 a0 00 cmp %g2, 0
4000776c: 02 80 00 07 be 40007788 <rtems_mkdir+0xd8>
<== NEVER TAKEN
40007770: 01 00 00 00 nop
oumask = umask(0);
40007774: 40 00 04 40 call 40008874 <umask>
40007778: 90 10 20 00 clr %o0 ! 0 <PROM_START>
4000777c: b6 10 00 08 mov %o0, %i3
(void)umask(numask);
40007780: 40 00 04 3d call 40008874 <umask>
40007784: 90 0a 3f 3f and %o0, -193, %o0
(void)umask(oumask);
40007788: 40 00 04 3b call 40008874 <umask>
4000778c: 90 10 00 1b mov %i3, %o0
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
40007790: 92 10 00 19 mov %i1, %o1
40007794: 7f ff fc 90 call 400069d4 <mkdir>
40007798: 90 10 00 1c mov %i4, %o0
4000779c: 80 a2 20 00 cmp %o0, 0
400077a0: 06 80 00 07 bl 400077bc <rtems_mkdir+0x10c>
400077a4: b4 10 20 01 mov 1, %i2
(void)umask(oumask);
400077a8: b0 10 20 00 clr %i0
success = build(dup_path, mode);
free(dup_path);
400077ac: 7f ff fb 22 call 40006434 <free>
400077b0: 90 10 00 1c mov %i4, %o0
400077b4: 81 c7 e0 08 ret
400077b8: 81 e8 00 00 restore
if (errno == EEXIST || errno == EISDIR) {
400077bc: 40 00 56 8b call 4001d1e8 <__errno>
400077c0: 01 00 00 00 nop
400077c4: c2 02 00 00 ld [ %o0 ], %g1
400077c8: 80 a0 60 11 cmp %g1, 0x11
400077cc: 02 80 00 08 be 400077ec <rtems_mkdir+0x13c>
<== ALWAYS TAKEN
400077d0: 92 07 bf a0 add %fp, -96, %o1
400077d4: 40 00 56 85 call 4001d1e8 <__errno>
<== NOT EXECUTED
400077d8: 01 00 00 00 nop
<== NOT EXECUTED
400077dc: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
400077e0: 80 a0 60 15 cmp %g1, 0x15
<== NOT EXECUTED
400077e4: 12 80 00 0f bne 40007820 <rtems_mkdir+0x170>
<== NOT EXECUTED
400077e8: 92 07 bf a0 add %fp, -96, %o1
<== NOT EXECUTED
if (stat(path, &sb) < 0) {
400077ec: 40 00 00 3c call 400078dc <stat>
400077f0: 90 10 00 1c mov %i4, %o0
400077f4: 80 a2 20 00 cmp %o0, 0
400077f8: 06 80 00 0a bl 40007820 <rtems_mkdir+0x170>
<== NEVER TAKEN
400077fc: c2 07 bf ac ld [ %fp + -84 ], %g1
} else if (!S_ISDIR(sb.st_mode)) {
40007800: 82 08 40 11 and %g1, %l1, %g1
40007804: 80 a0 40 10 cmp %g1, %l0
40007808: 12 80 00 10 bne 40007848 <rtems_mkdir+0x198>
<== NEVER TAKEN
4000780c: 80 a6 a0 00 cmp %i2, 0
if (last)
40007810: 32 bf ff e7 bne,a 400077ac <rtems_mkdir+0xfc>
<== ALWAYS TAKEN
40007814: b0 10 20 00 clr %i0
*p = '/';
40007818: 10 bf ff cd b 4000774c <rtems_mkdir+0x9c>
<== NOT EXECUTED
4000781c: f0 2f 7f ff stb %i0, [ %i5 + -1 ]
<== NOT EXECUTED
if (!first && !last)
40007820: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
40007824: 32 80 00 17 bne,a 40007880 <rtems_mkdir+0x1d0>
<== NOT EXECUTED
40007828: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
(void)umask(oumask);
4000782c: 40 00 04 12 call 40008874 <umask>
<== NOT EXECUTED
40007830: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
40007834: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
free(dup_path);
40007838: 7f ff fa ff call 40006434 <free>
<== NOT EXECUTED
4000783c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
40007840: 81 c7 e0 08 ret
<== NOT EXECUTED
40007844: 81 e8 00 00 restore
<== NOT EXECUTED
if (last)
40007848: 02 80 00 07 be 40007864 <rtems_mkdir+0x1b4>
<== NOT EXECUTED
4000784c: 01 00 00 00 nop
<== NOT EXECUTED
errno = EEXIST;
40007850: 40 00 56 66 call 4001d1e8 <__errno>
<== NOT EXECUTED
40007854: b0 10 3f ff mov -1, %i0 ! ffffffff <RAM_END+0xbfbfffff>
<== NOT EXECUTED
40007858: 82 10 20 11 mov 0x11, %g1
<== NOT EXECUTED
4000785c: 10 bf ff d4 b 400077ac <rtems_mkdir+0xfc>
<== NOT EXECUTED
40007860: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
errno = ENOTDIR;
40007864: 40 00 56 61 call 4001d1e8 <__errno>
<== NOT EXECUTED
40007868: 01 00 00 00 nop
<== NOT EXECUTED
4000786c: 82 10 20 14 mov 0x14, %g1 ! 14 <_TLS_Alignment+0x13>
<== NOT EXECUTED
40007870: 10 bf ff ef b 4000782c <rtems_mkdir+0x17c>
<== NOT EXECUTED
40007874: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
return success != 0 ? 0 : -1;
40007878: 81 c7 e0 08 ret
<== NOT EXECUTED
4000787c: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
free(dup_path);
40007880: 7f ff fa ed call 40006434 <free>
<== NOT EXECUTED
40007884: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
}
40007888: 81 c7 e0 08 ret
<== NOT EXECUTED
4000788c: 81 e8 00 00 restore
<== NOT EXECUTED
oumask = umask(0);
40007890: 40 00 03 f9 call 40008874 <umask>
<== NOT EXECUTED
40007894: 90 10 20 00 clr %o0
<== NOT EXECUTED
40007898: b6 10 00 08 mov %o0, %i3
<== NOT EXECUTED
(void)umask(numask);
4000789c: 40 00 03 f6 call 40008874 <umask>
<== NOT EXECUTED
400078a0: 90 0a 3f 3f and %o0, -193, %o0
<== NOT EXECUTED
if (last)
400078a4: 10 bf ff a2 b 4000772c <rtems_mkdir+0x7c>
<== NOT EXECUTED
400078a8: 80 8e a0 ff btst 0xff, %i2
<== NOT EXECUTED
40013580 <rtems_printf>:
int rtems_printf(
const rtems_printer *printer,
const char *format,
...
)
{
40013580: 9d e3 bf 98 save %sp, -104, %sp
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
va_list ap;
va_start( ap, format );
40013584: f4 27 a0 4c st %i2, [ %fp + 0x4c ]
{
40013588: 82 10 00 18 mov %i0, %g1
va_start( ap, format );
4001358c: f6 27 a0 50 st %i3, [ %fp + 0x50 ]
int len = 0;
40013590: b0 10 20 00 clr %i0
va_start( ap, format );
40013594: f8 27 a0 54 st %i4, [ %fp + 0x54 ]
40013598: 80 a0 60 00 cmp %g1, 0
4001359c: 02 80 00 0b be 400135c8 <rtems_printf+0x48>
<== NEVER TAKEN
400135a0: fa 27 a0 58 st %i5, [ %fp + 0x58 ]
400135a4: c4 00 60 04 ld [ %g1 + 4 ], %g2
400135a8: 80 a0 a0 00 cmp %g2, 0
400135ac: 02 80 00 07 be 400135c8 <rtems_printf+0x48>
<== NEVER TAKEN
400135b0: 94 07 a0 4c add %fp, 0x4c, %o2
len = printer->printer( printer->context, format, ap );
400135b4: d0 00 40 00 ld [ %g1 ], %o0
400135b8: 92 10 00 19 mov %i1, %o1
400135bc: 9f c0 80 00 call %g2
400135c0: d4 27 bf fc st %o2, [ %fp + -4 ]
400135c4: b0 10 00 08 mov %o0, %i0
va_end( ap );
}
return len;
}
400135c8: 81 c7 e0 08 ret
400135cc: 81 e8 00 00 restore
4000839c <rtems_resource_snapshot_take>:
return count;
}
void rtems_resource_snapshot_take(rtems_resource_snapshot *snapshot)
{
4000839c: 9d e3 bf 98 save %sp, -104, %sp
uint32_t *active;
size_t i;
memset(snapshot, 0, sizeof(*snapshot));
400083a0: 94 10 20 f8 mov 0xf8, %o2
400083a4: 92 10 20 00 clr %o1
400083a8: 40 00 34 d8 call 40015708 <memset>
400083ac: 90 10 00 18 mov %i0, %o0
_RTEMS_Lock_allocator();
400083b0: 40 00 05 de call 40009b28 <_RTEMS_Lock_allocator>
400083b4: 3b 10 00 8d sethi %hi(0x40023400), %i5
_Thread_Kill_zombies();
400083b8: 40 00 19 2b call 4000e864 <_Thread_Kill_zombies>
400083bc: b8 06 20 b4 add %i0, 0xb4, %i4
get_heap_info(RTEMS_Malloc_Heap, &snapshot->heap_info);
400083c0: 03 10 00 94 sethi %hi(0x40025000), %g1
_Heap_Get_information(heap, info);
400083c4: d0 00 60 7c ld [ %g1 + 0x7c ], %o0 ! 4002507c <RTEMS_Malloc_Heap>
400083c8: 40 00 06 ed call 40009f7c <_Heap_Get_information>
400083cc: 92 06 20 58 add %i0, 0x58, %o1
memset(&info->Stats, 0, sizeof(info->Stats));
400083d0: 94 10 20 40 mov 0x40, %o2
400083d4: 92 10 20 00 clr %o1
400083d8: 40 00 34 cc call 40015708 <memset>
400083dc: 90 06 20 70 add %i0, 0x70, %o0
_Heap_Get_information(heap, info);
400083e0: 92 10 00 18 mov %i0, %o1
400083e4: 11 10 00 9c sethi %hi(0x40027000), %o0
400083e8: 40 00 06 e5 call 40009f7c <_Heap_Get_information>
400083ec: 90 12 21 20 or %o0, 0x120, %o0 ! 40027120 <_Workspace_Area>
memset(&info->Stats, 0, sizeof(info->Stats));
400083f0: 92 10 20 00 clr %o1
400083f4: 94 10 20 40 mov 0x40, %o2
400083f8: 40 00 34 c4 call 40015708 <memset>
400083fc: 90 06 20 18 add %i0, 0x18, %o0
40008400: ba 17 60 28 or %i5, 0x28, %i5
get_heap_info(&_Workspace_Area, &snapshot->workspace_info);
active = &snapshot->active_posix_keys;
40008404: 92 10 20 02 mov 2, %o1
40008408: 90 10 20 03 mov 3, %o0
4000840c: 10 80 00 05 b 40008420 <rtems_resource_snapshot_take+0x84>
40008410: b6 07 60 70 add %i5, 0x70, %i3
40008414: d0 07 40 00 ld [ %i5 ], %o0
40008418: d2 17 60 04 lduh [ %i5 + 4 ], %o1
4000841c: ba 07 60 08 add %i5, 8, %i5
for (i = 0; i < RTEMS_ARRAY_SIZE(objects_info_table); ++i) {
const Objects_Information *information;
information = _Objects_Get_information(
40008420: 93 2a 60 10 sll %o1, 0x10, %o1
40008424: 40 00 0e cb call 4000bf50 <_Objects_Get_information>
40008428: 93 32 60 10 srl %o1, 0x10, %o1
objects_info_table[i].api,
objects_info_table[i].cls
);
if (information != NULL) {
4000842c: 80 a2 20 00 cmp %o0, 0
40008430: 02 80 00 08 be 40008450 <rtems_resource_snapshot_take+0xb4>
40008434: 80 a7 40 1b cmp %i5, %i3
active[i] = _Objects_Active_count(information);
40008438: 40 00 0d bd call 4000bb2c <_Objects_Active_count>
4000843c: 01 00 00 00 nop
40008440: 91 2a 20 10 sll %o0, 0x10, %o0
40008444: 91 32 20 10 srl %o0, 0x10, %o0
40008448: d0 27 00 00 st %o0, [ %i4 ]
for (i = 0; i < RTEMS_ARRAY_SIZE(objects_info_table); ++i) {
4000844c: 80 a7 40 1b cmp %i5, %i3
40008450: 12 bf ff f1 bne 40008414 <rtems_resource_snapshot_take+0x78>
40008454: b8 07 20 04 add %i4, 4, %i4
}
}
_RTEMS_Unlock_allocator();
40008458: 40 00 05 b9 call 40009b3c <_RTEMS_Unlock_allocator>
4000845c: 39 10 00 9b sethi %hi(0x40026c00), %i4
uint32_t count = 0;
40008460: ba 10 20 00 clr %i5
Objects_Id id = OBJECTS_ID_INITIAL_INDEX;
40008464: c0 27 bf fc clr [ %fp + -4 ]
40008468: 90 10 20 00 clr %o0
return (POSIX_Keys_Control *)
4000846c: 10 80 00 07 b 40008488 <rtems_resource_snapshot_take+0xec>
40008470: b8 17 20 28 or %i4, 0x28, %i4
count += _Chain_Node_count_unprotected(&the_key->Key_value_pairs);
40008474: 40 00 05 cf call 40009bb0 <_Chain_Node_count_unprotected>
40008478: 01 00 00 00 nop
* previous thread life protection state and thus may not return if the
* executing thread was restarted or deleted in the mean-time.
*/
RTEMS_INLINE_ROUTINE void _Objects_Allocator_unlock( void )
{
_RTEMS_Unlock_allocator();
4000847c: 40 00 05 b0 call 40009b3c <_RTEMS_Unlock_allocator>
40008480: ba 07 40 08 add %i5, %o0, %i5
40008484: d0 07 bf fc ld [ %fp + -4 ], %o0
return (POSIX_Keys_Control *)
40008488: 94 07 bf fc add %fp, -4, %o2
4000848c: 40 00 0e ce call 4000bfc4 <_Objects_Get_next>
40008490: 92 10 00 1c mov %i4, %o1
40008494: 82 10 00 08 mov %o0, %g1
while ((the_key = get_next_key(&id)) != NULL ) {
40008498: 80 a0 60 00 cmp %g1, 0
4000849c: 12 bf ff f6 bne 40008474 <rtems_resource_snapshot_take+0xd8>
400084a0: 90 02 20 14 add %o0, 0x14, %o0
snapshot->active_posix_key_value_pairs = get_active_posix_key_value_pairs();
400084a4: fa 26 20 b0 st %i5, [ %i0 + 0xb0 ]
rtems_libio_lock();
400084a8: 7f ff fc 1d call 4000751c <rtems_libio_lock>
400084ac: ba 10 20 00 clr %i5
iop = rtems_libio_iop_free_head;
400084b0: 03 10 00 9b sethi %hi(0x40026c00), %g1
400084b4: c2 00 60 20 ld [ %g1 + 0x20 ], %g1 ! 40026c20 <rtems_libio_iop_free_head>
while (iop != NULL) {
400084b8: 80 a0 60 00 cmp %g1, 0
400084bc: 02 80 00 06 be 400084d4 <rtems_resource_snapshot_take+0x138>
<== NEVER TAKEN
400084c0: 01 00 00 00 nop
iop = iop->data1;
400084c4: c2 00 60 28 ld [ %g1 + 0x28 ], %g1
while (iop != NULL) {
400084c8: 80 a0 60 00 cmp %g1, 0
400084cc: 12 bf ff fe bne 400084c4 <rtems_resource_snapshot_take+0x128>
400084d0: ba 07 60 01 inc %i5
rtems_libio_unlock();
400084d4: 7f ff fc 17 call 40007530 <rtems_libio_unlock>
400084d8: 01 00 00 00 nop
return (int) rtems_libio_number_iops - free_count;
400084dc: 03 10 00 8b sethi %hi(0x40022c00), %g1
400084e0: c2 00 61 20 ld [ %g1 + 0x120 ], %g1 ! 40022d20 <rtems_libio_number_iops>
400084e4: ba 20 40 1d sub %g1, %i5, %i5
snapshot->open_files = open_files();
400084e8: fa 26 20 f0 st %i5, [ %i0 + 0xf0 ]
}
400084ec: 81 c7 e0 08 ret
400084f0: 81 e8 00 00 restore
40013544 <rtems_vprintf>:
int rtems_vprintf(
const rtems_printer *printer,
const char *format,
va_list ap
)
{
40013544: 9d e3 bf a0 save %sp, -96, %sp
40013548: 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;
4001354c: 80 a0 60 00 cmp %g1, 0
40013550: 02 80 00 0a be 40013578 <rtems_vprintf+0x34>
<== NEVER TAKEN
40013554: b0 10 20 00 clr %i0
40013558: c4 00 60 04 ld [ %g1 + 4 ], %g2
4001355c: 80 a0 a0 00 cmp %g2, 0
40013560: 02 80 00 06 be 40013578 <rtems_vprintf+0x34>
<== NEVER TAKEN
40013564: 94 10 00 1a mov %i2, %o2
int len = 0;
if ( rtems_print_printer_valid( printer ) ) {
len = printer->printer( printer->context, format, ap );
40013568: d0 00 40 00 ld [ %g1 ], %o0
4001356c: 9f c0 80 00 call %g2
40013570: 92 10 00 19 mov %i1, %o1
40013574: b0 10 00 08 mov %o0, %i0
}
return len;
}
40013578: 81 c7 e0 08 ret
4001357c: 81 e8 00 00 restore
4000733c <unmount>:
* in some form is supported on most UNIX and POSIX systems. This
* routine is necessary to mount instantiations of a file system
* into the file system name space.
*/
int unmount( const char *path )
{
4000733c: 9d e3 bf 60 save %sp, -160, %sp
int rv = 0;
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
const rtems_filesystem_location_info_t *currentloc =
40007340: 94 10 20 18 mov 0x18, %o2
40007344: 92 10 00 18 mov %i0, %o1
40007348: 7f ff fd 95 call 4000699c <rtems_filesystem_eval_path_start>
4000734c: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
rtems_filesystem_mount_table_entry_t *mt_entry = currentloc->mt_entry;
40007350: fa 02 20 14 ld [ %o0 + 0x14 ], %i5
40007354: c2 07 60 0c ld [ %i5 + 0xc ], %g1
40007358: c2 00 60 10 ld [ %g1 + 0x10 ], %g1
4000735c: 9f c0 40 00 call %g1
40007360: d2 07 60 24 ld [ %i5 + 0x24 ], %o1
if ( rtems_filesystem_location_is_instance_root( currentloc ) ) {
40007364: 80 a2 20 00 cmp %o0, 0
40007368: 02 80 00 34 be 40007438 <unmount+0xfc>
<== NEVER TAKEN
4000736c: 01 00 00 00 nop
&rtems_filesystem_root->location;
40007370: 7f ff fb 97 call 400061cc <rtems_current_user_env_get>
40007374: 01 00 00 00 nop
&rtems_filesystem_current->location;
40007378: 7f ff fb 95 call 400061cc <rtems_current_user_env_get>
4000737c: f8 02 20 04 ld [ %o0 + 4 ], %i4
return mt_entry == root->mt_entry || mt_entry == current->mt_entry;
40007380: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40007384: 80 a7 40 01 cmp %i5, %g1
40007388: 02 80 00 14 be 400073d8 <unmount+0x9c>
<== NEVER TAKEN
4000738c: 01 00 00 00 nop
40007390: c2 02 00 00 ld [ %o0 ], %g1
40007394: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
40007398: 80 a7 40 01 cmp %i5, %g1
4000739c: 02 80 00 0f be 400073d8 <unmount+0x9c>
<== NEVER TAKEN
400073a0: 01 00 00 00 nop
if ( !contains_root_or_current_directory( mt_entry ) ) {
const rtems_filesystem_operations_table *mt_point_ops =
mt_entry->mt_point_node->location.mt_entry->ops;
400073a4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
const rtems_filesystem_operations_table *mt_point_ops =
400073a8: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
rv = (*mt_point_ops->unmount_h)( mt_entry );
400073ac: c2 00 60 0c ld [ %g1 + 0xc ], %g1
400073b0: c2 00 60 30 ld [ %g1 + 0x30 ], %g1
400073b4: 9f c0 40 00 call %g1
400073b8: 90 10 00 1d mov %i5, %o0
if ( rv == 0 ) {
400073bc: b0 92 20 00 orcc %o0, 0, %i0
400073c0: 02 80 00 0b be 400073ec <unmount+0xb0>
400073c4: 01 00 00 00 nop
} else {
errno = EACCES;
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
400073c8: 7f ff fd bf call 40006ac4 <rtems_filesystem_eval_path_cleanup>
400073cc: 90 07 bf c8 add %fp, -56, %o0
rtems_fatal_error_occurred( 0xdeadbeef );
}
}
return rv;
}
400073d0: 81 c7 e0 08 ret
400073d4: 81 e8 00 00 restore
errno = EBUSY;
400073d8: 40 00 4f 59 call 4001b13c <__errno>
<== NOT EXECUTED
400073dc: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400073e0: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
400073e4: 10 bf ff f9 b 400073c8 <unmount+0x8c>
<== NOT EXECUTED
400073e8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_id self_task_id = rtems_task_self();
400073ec: 40 00 01 7b call 400079d8 <rtems_task_self>
400073f0: 01 00 00 00 nop
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400073f4: 91 d0 20 09 ta 9
<== NOT EXECUTED
mt_entry->unmount_task = self_task_id;
400073f8: d0 27 60 3c st %o0, [ %i5 + 0x3c ]
<== NOT EXECUTED
mt_entry->mounted = false;
400073fc: c0 2f 60 28 clrb [ %i5 + 0x28 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40007400: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40007404: 01 00 00 00 nop
rtems_filesystem_eval_path_cleanup( &ctx );
40007408: 7f ff fd af call 40006ac4 <rtems_filesystem_eval_path_cleanup>
4000740c: 90 07 bf c8 add %fp, -56, %o0
rtems_interval ticks
)
{
rtems_event_set event_out;
return rtems_event_system_receive(
40007410: 96 07 bf c4 add %fp, -60, %o3
40007414: 94 10 20 00 clr %o2
40007418: 92 10 20 00 clr %o1
4000741c: 40 00 01 11 call 40007860 <rtems_event_system_receive>
40007420: 11 20 00 00 sethi %hi(0x80000000), %o0
if ( sc != RTEMS_SUCCESSFUL ) {
40007424: 80 a2 20 00 cmp %o0, 0
40007428: 02 bf ff ea be 400073d0 <unmount+0x94>
<== ALWAYS TAKEN
4000742c: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
rtems_fatal_error_occurred( 0xdeadbeef );
40007430: 40 00 01 a0 call 40007ab0 <rtems_fatal_error_occurred>
<== NOT EXECUTED
40007434: 90 12 22 ef or %o0, 0x2ef, %o0 ! deadbeef <RAM_END+0x9e6dbeef>
<== NOT EXECUTED
errno = EACCES;
40007438: 40 00 4f 41 call 4001b13c <__errno>
<== NOT EXECUTED
4000743c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40007440: 82 10 20 0d mov 0xd, %g1
<== NOT EXECUTED
40007444: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
40007448: 7f ff fd 9f call 40006ac4 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
4000744c: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
40007450: 81 c7 e0 08 ret
<== NOT EXECUTED
40007454: 81 e8 00 00 restore
<== NOT EXECUTED
40006508 <utime>:
/**
* POSIX 1003.1b 5.5.6 - Set File Access and Modification Times
*/
int utime( const char *path, const struct utimbuf *times )
{
40006508: 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;
const rtems_filesystem_location_info_t *currentloc =
4000650c: 94 10 20 18 mov 0x18, %o2
40006510: 92 10 00 18 mov %i0, %o1
40006514: 7f ff fd 4a call 40005a3c <rtems_filesystem_eval_path_start>
40006518: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
struct utimbuf now_times;
if ( times == NULL ) {
4000651c: 80 a6 60 00 cmp %i1, 0
40006520: 02 80 00 11 be 40006564 <utime+0x5c>
<== NEVER TAKEN
40006524: ba 10 00 08 mov %o0, %i5
now_times.modtime = now;
times = &now_times;
}
rv = (*currentloc->mt_entry->ops->utime_h)(
40006528: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000652c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40006530: d0 06 40 00 ld [ %i1 ], %o0
40006534: d4 06 60 04 ld [ %i1 + 4 ], %o2
40006538: d6 06 60 08 ld [ %i1 + 8 ], %o3
4000653c: d8 06 60 0c ld [ %i1 + 0xc ], %o4
40006540: c2 00 60 38 ld [ %g1 + 0x38 ], %g1
40006544: 92 10 00 08 mov %o0, %o1
40006548: 9f c0 40 00 call %g1
4000654c: 90 10 00 1d mov %i5, %o0
40006550: b0 10 00 08 mov %o0, %i0
currentloc,
times->actime,
times->modtime
);
rtems_filesystem_eval_path_cleanup( &ctx );
40006554: 7f ff fd 84 call 40005b64 <rtems_filesystem_eval_path_cleanup>
40006558: 90 07 bf c8 add %fp, -56, %o0
return rv;
}
4000655c: 81 c7 e0 08 ret
40006560: 81 e8 00 00 restore
time_t now = time( NULL );
40006564: 40 00 20 b2 call 4000e82c <time>
<== NOT EXECUTED
40006568: 90 10 20 00 clr %o0
<== NOT EXECUTED
rv = (*currentloc->mt_entry->ops->utime_h)(
4000656c: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
40006570: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
40006574: c2 00 60 38 ld [ %g1 + 0x38 ], %g1
<== NOT EXECUTED
time_t now = time( NULL );
40006578: 94 10 00 09 mov %o1, %o2
<== NOT EXECUTED
4000657c: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
40006580: 98 10 00 09 mov %o1, %o4
<== NOT EXECUTED
rv = (*currentloc->mt_entry->ops->utime_h)(
40006584: 92 10 00 08 mov %o0, %o1
<== NOT EXECUTED
40006588: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000658c: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
40006590: b0 10 00 08 mov %o0, %i0
<== NOT EXECUTED
rtems_filesystem_eval_path_cleanup( &ctx );
40006594: 7f ff fd 74 call 40005b64 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
40006598: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
}
4000659c: 81 c7 e0 08 ret
<== NOT EXECUTED
400065a0: 81 e8 00 00 restore
<== NOT EXECUTED
400226ac <write>:
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
400226ac: 9d e3 bf a0 save %sp, -96, %sp
rtems_libio_t *iop;
ssize_t n;
rtems_libio_check_buffer( buffer );
400226b0: 80 a6 60 00 cmp %i1, 0
400226b4: 02 80 00 32 be 4002277c <write+0xd0>
<== NEVER TAKEN
400226b8: 80 a6 a0 00 cmp %i2, 0
rtems_libio_check_count( count );
400226bc: 02 80 00 22 be 40022744 <write+0x98>
<== NEVER TAKEN
400226c0: 84 10 20 00 clr %g2
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
400226c4: 03 10 00 8b sethi %hi(0x40022c00), %g1
400226c8: c2 00 61 20 ld [ %g1 + 0x120 ], %g1 ! 40022d20 <rtems_libio_number_iops>
400226cc: 80 a6 00 01 cmp %i0, %g1
400226d0: 1a 80 00 25 bcc 40022764 <write+0xb8>
<== NEVER TAKEN
400226d4: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
400226d8: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
400226dc: 31 10 00 99 sethi %hi(0x40026400), %i0
<== NOT EXECUTED
400226e0: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
400226e4: b0 16 22 c0 or %i0, 0x2c0, %i0
<== NOT EXECUTED
400226e8: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
400226ec: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
400226f0: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
400226f4: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
400226f8: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400226fc: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40022700: 01 00 00 00 nop
40022704: 84 08 a1 04 and %g2, 0x104, %g2
40022708: 80 a0 a1 04 cmp %g2, 0x104
4002270c: 12 80 00 10 bne 4002274c <write+0xa0>
40022710: 94 10 00 1a mov %i2, %o2
/*
* Now process the write() request.
*/
n = (*iop->pathinfo.handlers->write_h)( iop, buffer, count );
40022714: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40022718: c2 00 60 0c ld [ %g1 + 0xc ], %g1
4002271c: 92 10 00 19 mov %i1, %o1
40022720: 9f c0 40 00 call %g1
40022724: 90 10 00 1d mov %i5, %o0
40022728: 84 10 00 08 mov %o0, %g2
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002272c: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40022730: c6 07 60 08 ld [ %i5 + 8 ], %g3
<== NOT EXECUTED
40022734: 86 00 f0 00 add %g3, -4096, %g3
<== NOT EXECUTED
40022738: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002273c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40022740: 01 00 00 00 nop
rtems_libio_iop_drop( iop );
return n;
}
40022744: 81 c7 e0 08 ret
40022748: 91 e8 00 02 restore %g0, %g2, %o0
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4002274c: 91 d0 20 09 ta 9
<== NOT EXECUTED
40022750: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40022754: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40022758: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4002275c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40022760: 01 00 00 00 nop
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, LIBIO_FLAGS_WRITE, EBADF );
40022764: 7f ff c9 d9 call 40014ec8 <__errno>
40022768: 01 00 00 00 nop
4002276c: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
40022770: 84 10 3f ff mov -1, %g2
40022774: 10 bf ff f4 b 40022744 <write+0x98>
40022778: c2 22 00 00 st %g1, [ %o0 ]
rtems_libio_check_buffer( buffer );
4002277c: 7f ff c9 d3 call 40014ec8 <__errno>
<== NOT EXECUTED
40022780: 01 00 00 00 nop
<== NOT EXECUTED
40022784: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
40022788: 84 10 3f ff mov -1, %g2
<== NOT EXECUTED
4002278c: 10 bf ff ee b 40022744 <write+0x98>
<== NOT EXECUTED
40022790: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40008378 <writev>:
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
40008378: 9d e3 bf a0 save %sp, -96, %sp
if ( iov == NULL )
4000837c: 80 a6 60 00 cmp %i1, 0
40008380: 02 80 00 3f be 4000847c <writev+0x104>
<== NEVER TAKEN
40008384: 80 a6 a0 00 cmp %i2, 0
if ( iovcnt <= 0 )
40008388: 04 80 00 3d ble 4000847c <writev+0x104>
<== NEVER TAKEN
4000838c: 80 a6 a4 00 cmp %i2, 0x400
if ( iovcnt > IOV_MAX )
40008390: 14 80 00 3b bg 4000847c <writev+0x104>
<== NEVER TAKEN
40008394: bb 2e a0 03 sll %i2, 3, %i5
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
40008398: 09 1f ff ff sethi %hi(0x7ffffc00), %g4
4000839c: 82 10 00 19 mov %i1, %g1
400083a0: ba 07 40 19 add %i5, %i1, %i5
total = 0;
400083a4: 96 10 20 00 clr %o3
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
400083a8: 88 11 23 ff or %g4, 0x3ff, %g4
size_t len = iov[ v ].iov_len;
400083ac: c4 00 60 04 ld [ %g1 + 4 ], %g2
if ( len > ( size_t ) ( SSIZE_MAX - total ) ) {
400083b0: 86 21 00 0b sub %g4, %o3, %g3
400083b4: 80 a0 80 03 cmp %g2, %g3
400083b8: 18 80 00 31 bgu 4000847c <writev+0x104>
<== NEVER TAKEN
400083bc: 01 00 00 00 nop
if ( iov[ v ].iov_base == NULL && len != 0 ) {
400083c0: c6 00 40 00 ld [ %g1 ], %g3
400083c4: 80 a0 e0 00 cmp %g3, 0
400083c8: 12 80 00 05 bne 400083dc <writev+0x64>
<== ALWAYS TAKEN
400083cc: 96 02 c0 02 add %o3, %g2, %o3
400083d0: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
400083d4: 12 80 00 2a bne 4000847c <writev+0x104>
<== NOT EXECUTED
400083d8: 01 00 00 00 nop
<== NOT EXECUTED
400083dc: 82 00 60 08 add %g1, 8, %g1
for ( v = 0 ; v < iovcnt ; ++v ) {
400083e0: 80 a7 40 01 cmp %i5, %g1
400083e4: 32 bf ff f3 bne,a 400083b0 <writev+0x38>
<== NEVER TAKEN
400083e8: c4 00 60 04 ld [ %g1 + 4 ], %g2
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
400083ec: 03 10 00 67 sethi %hi(0x40019c00), %g1
400083f0: c2 00 63 88 ld [ %g1 + 0x388 ], %g1 ! 40019f88 <rtems_libio_number_iops>
400083f4: 80 a6 00 01 cmp %i0, %g1
400083f8: 1a 80 00 2e bcc 400084b0 <writev+0x138>
<== NEVER TAKEN
400083fc: bb 2e 20 01 sll %i0, 1, %i5
<== NOT EXECUTED
return &rtems_libio_iops[ fd ];
40008400: 03 10 00 75 sethi %hi(0x4001d400), %g1
<== NOT EXECUTED
40008404: ba 07 40 18 add %i5, %i0, %i5
<== NOT EXECUTED
40008408: 82 10 60 a0 or %g1, 0xa0, %g1
<== NOT EXECUTED
4000840c: bb 2f 60 04 sll %i5, 4, %i5
<== NOT EXECUTED
40008410: ba 07 40 01 add %i5, %g1, %i5
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008414: 91 d0 20 09 ta 9
<== NOT EXECUTED
val = *obj;
40008418: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
*obj = val + arg;
4000841c: 86 20 b0 00 sub %g2, -4096, %g3
<== NOT EXECUTED
40008420: c6 27 60 08 st %g3, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
40008424: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008428: 01 00 00 00 nop
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
4000842c: 84 08 a1 04 and %g2, 0x104, %g2
40008430: 80 a0 a1 04 cmp %g2, 0x104
40008434: 12 80 00 19 bne 40008498 <writev+0x120>
<== NEVER TAKEN
40008438: 80 a2 e0 00 cmp %o3, 0
if ( total > 0 ) {
4000843c: 04 80 00 08 ble 4000845c <writev+0xe4>
<== NEVER TAKEN
40008440: 94 10 00 1a mov %i2, %o2
return ( *iop->pathinfo.handlers->writev_h )( iop, iov, iovcnt, total );
40008444: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
40008448: c2 00 60 38 ld [ %g1 + 0x38 ], %g1
4000844c: 92 10 00 19 mov %i1, %o1
40008450: 9f c0 40 00 call %g1
40008454: 90 10 00 1d mov %i5, %o0
40008458: 96 10 00 08 mov %o0, %o3
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000845c: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val - arg;
40008460: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
40008464: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
40008468: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000846c: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
40008470: 01 00 00 00 nop
iov,
iovcnt,
LIBIO_FLAGS_WRITE,
writev_adapter
);
}
40008474: 81 c7 e0 08 ret
40008478: 91 e8 00 0b restore %g0, %o3, %o0
rtems_set_errno_and_return_minus_one( EINVAL );
4000847c: 40 00 21 74 call 40010a4c <__errno>
<== NOT EXECUTED
40008480: 01 00 00 00 nop
<== NOT EXECUTED
40008484: 82 10 20 16 mov 0x16, %g1 ! 16 <_TLS_Alignment+0x15>
<== NOT EXECUTED
40008488: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000848c: 96 10 3f ff mov -1, %o3
<== NOT EXECUTED
40008490: 81 c7 e0 08 ret
<== NOT EXECUTED
40008494: 91 e8 00 0b restore %g0, %o3, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
40008498: 91 d0 20 09 ta 9
<== NOT EXECUTED
4000849c: c4 07 60 08 ld [ %i5 + 8 ], %g2
<== NOT EXECUTED
400084a0: 84 00 b0 00 add %g2, -4096, %g2
<== NOT EXECUTED
400084a4: c4 27 60 08 st %g2, [ %i5 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
400084a8: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
400084ac: 01 00 00 00 nop
<== NOT EXECUTED
LIBIO_GET_IOP_WITH_ACCESS( fd, iop, flags, EBADF );
400084b0: 40 00 21 67 call 40010a4c <__errno>
<== NOT EXECUTED
400084b4: 01 00 00 00 nop
<== NOT EXECUTED
400084b8: 82 10 20 09 mov 9, %g1 ! 9 <_TLS_Alignment+0x8>
<== NOT EXECUTED
400084bc: 96 10 3f ff mov -1, %o3
<== NOT EXECUTED
400084c0: 10 bf ff f4 b 40008490 <writev+0x118>
<== NOT EXECUTED
400084c4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED