40003a08 <IMFS_fchmod>:
int IMFS_fchmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
40003a08: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
IMFS_jnode_t *jnode;
jnode = loc->node_access;
40003a0c: fa 06 20 08 ld [ %i0 + 8 ], %i5
<== NOT EXECUTED
jnode->st_mode = mode;
40003a10: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
40003a14: 40 00 14 14 call 40008a64 <_Timecounter_Getbintime>
<== NOT EXECUTED
40003a18: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
return now.sec;
40003a1c: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_ctime = _IMFS_get_time();
40003a20: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
IMFS_update_ctime( jnode );
return 0;
}
40003a24: 81 c7 e0 08 ret
40003a28: 91 e8 20 00 restore %g0, 0, %o0
4000c384 <IMFS_fsunmount>:
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
void IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
4000c384: 9d e3 bf 88 save %sp, -120, %sp
<== NOT EXECUTED
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
loc = temp_mt_entry->mt_fs_root->location;
4000c388: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
<== NOT EXECUTED
4000c38c: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
4000c390: f6 00 40 00 ld [ %g1 ], %i3
<== NOT EXECUTED
4000c394: f8 00 60 04 ld [ %g1 + 4 ], %i4
<== NOT EXECUTED
4000c398: c8 00 60 0c ld [ %g1 + 0xc ], %g4
<== NOT EXECUTED
4000c39c: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
<== NOT EXECUTED
4000c3a0: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
jnode = (IMFS_jnode_t *)loc.node_access;
4000c3a4: ba 10 00 02 mov %g2, %i5
loc = temp_mt_entry->mt_fs_root->location;
4000c3a8: c4 27 bf f0 st %g2, [ %fp + -16 ]
return S_ISDIR( node->st_mode );
4000c3ac: 35 00 00 3c sethi %hi(0xf000), %i2
4000c3b0: c2 27 bf fc st %g1, [ %fp + -4 ]
4000c3b4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
loc->handlers = node->control->handlers;
4000c3b8: c4 07 60 38 ld [ %i5 + 0x38 ], %g2
4000c3bc: c4 00 80 00 ld [ %g2 ], %g2
4000c3c0: c6 27 bf f8 st %g3, [ %fp + -8 ]
return S_ISDIR( node->st_mode );
4000c3c4: 82 08 40 1a and %g1, %i2, %g1
4000c3c8: f6 27 bf e8 st %i3, [ %fp + -24 ]
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000c3cc: 37 00 00 10 sethi %hi(0x4000), %i3
loc = temp_mt_entry->mt_fs_root->location;
4000c3d0: f8 27 bf ec st %i4, [ %fp + -20 ]
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000c3d4: 80 a0 40 1b cmp %g1, %i3
next = jnode->Parent;
4000c3d8: f8 07 60 08 ld [ %i5 + 8 ], %i4
loc = temp_mt_entry->mt_fs_root->location;
4000c3dc: c8 27 bf f4 st %g4, [ %fp + -12 ]
loc.node_access = (void *)jnode;
4000c3e0: fa 27 bf f0 st %i5, [ %fp + -16 ]
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000c3e4: 12 80 00 14 bne 4000c434 <IMFS_fsunmount+0xb0>
<== NEVER TAKEN
4000c3e8: c4 27 bf f8 st %g2, [ %fp + -8 ]
return _Chain_Immutable_head( the_chain )->next;
4000c3ec: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
return &the_chain->Tail.Node;
4000c3f0: 82 07 60 44 add %i5, 0x44, %g1
4000c3f4: 80 a0 80 01 cmp %g2, %g1
4000c3f8: 02 80 00 10 be 4000c438 <IMFS_fsunmount+0xb4>
4000c3fc: 92 07 bf e8 add %fp, -24, %o1
if ( IMFS_is_directory( jnode ) ) {
if ( jnode_has_children( jnode ) )
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
4000c400: 80 a0 a0 00 cmp %g2, 0
4000c404: 02 80 00 23 be 4000c490 <IMFS_fsunmount+0x10c>
<== NEVER TAKEN
4000c408: b8 10 00 02 mov %g2, %i4
4000c40c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
4000c410: ba 10 00 1c mov %i4, %i5
loc->handlers = node->control->handlers;
4000c414: c4 07 60 38 ld [ %i5 + 0x38 ], %g2
4000c418: c4 00 80 00 ld [ %g2 ], %g2
next = jnode->Parent;
4000c41c: f8 07 60 08 ld [ %i5 + 8 ], %i4
loc.node_access = (void *)jnode;
4000c420: fa 27 bf f0 st %i5, [ %fp + -16 ]
return S_ISDIR( node->st_mode );
4000c424: 82 08 40 1a and %g1, %i2, %g1
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000c428: 80 a0 40 1b cmp %g1, %i3
4000c42c: 02 bf ff f0 be 4000c3ec <IMFS_fsunmount+0x68>
4000c430: c4 27 bf f8 st %g2, [ %fp + -8 ]
result = IMFS_rmnod( NULL, &loc );
4000c434: 92 07 bf e8 add %fp, -24, %o1
4000c438: 7f ff df 23 call 400040c4 <IMFS_rmnod>
4000c43c: 90 10 20 00 clr %o0
if ( result != 0 )
4000c440: 80 a2 20 00 cmp %o0, 0
4000c444: 12 80 00 15 bne 4000c498 <IMFS_fsunmount+0x114>
<== NEVER TAKEN
4000c448: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
IMFS_node_destroy( jnode );
4000c44c: 7f ff de bb call 40003f38 <IMFS_node_destroy>
4000c450: 90 10 00 1d mov %i5, %o0
if ( jnode != NULL ) {
4000c454: 80 a7 20 00 cmp %i4, 0
4000c458: 02 80 00 0e be 4000c490 <IMFS_fsunmount+0x10c>
4000c45c: 01 00 00 00 nop
4000c460: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
4000c464: 84 08 40 1a and %g1, %i2, %g2
if ( IMFS_is_directory( jnode ) ) {
4000c468: 80 a0 80 1b cmp %g2, %i3
4000c46c: 32 bf ff ea bne,a 4000c414 <IMFS_fsunmount+0x90>
<== NEVER TAKEN
4000c470: ba 10 00 1c mov %i4, %i5
<== NOT EXECUTED
4000c474: c4 07 20 40 ld [ %i4 + 0x40 ], %g2
if ( jnode_has_children( jnode ) )
4000c478: 86 07 20 44 add %i4, 0x44, %g3
4000c47c: 80 a0 80 03 cmp %g2, %g3
4000c480: 12 bf ff e1 bne 4000c404 <IMFS_fsunmount+0x80>
4000c484: 80 a0 a0 00 cmp %g2, 0
} while (jnode != NULL);
4000c488: 10 bf ff e3 b 4000c414 <IMFS_fsunmount+0x90>
4000c48c: ba 10 00 1c mov %i4, %i5
}
4000c490: 81 c7 e0 08 ret
4000c494: 81 e8 00 00 restore
rtems_fatal_error_occurred( 0xdeadbeef );
4000c498: 7f ff e9 59 call 400069fc <rtems_fatal_error_occurred>
<== NOT EXECUTED
4000c49c: 90 12 22 ef or %o0, 0x2ef, %o0
<== NOT EXECUTED
4000c4a0: 01 00 00 00 nop
<== NOT EXECUTED
40004880 <IMFS_initialize_node>:
const char *name,
size_t namelen,
mode_t mode,
void *arg
)
{
40004880: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
struct timeval tv;
if ( namelen > IMFS_NAME_MAX ) {
40004884: 80 a6 e0 ff cmp %i3, 0xff
<== NOT EXECUTED
40004888: 18 80 00 19 bgu 400048ec <IMFS_initialize_node+0x6c>
<== NOT EXECUTED
4000488c: 92 10 20 00 clr %o1
errno = ENAMETOOLONG;
return NULL;
}
gettimeofday( &tv, 0 );
40004890: 40 00 01 aa call 40004f38 <gettimeofday>
40004894: 90 07 bf f0 add %fp, -16, %o0
/*
* Fill in the basic information
*/
node->name = name;
node->namelen = namelen;
node->reference_count = 1;
40004898: 03 00 00 40 sethi %hi(0x10000), %g1
node->name = name;
4000489c: f4 26 20 0c st %i2, [ %i0 + 0xc ]
node->reference_count = 1;
400048a0: 82 10 60 01 or %g1, 1, %g1
node->namelen = namelen;
400048a4: f6 36 20 10 sth %i3, [ %i0 + 0x10 ]
node->reference_count = 1;
400048a8: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
node->st_nlink = 1;
node->control = node_control;
400048ac: f2 26 20 38 st %i1, [ %i0 + 0x38 ]
/*
* Fill in the mode and permission information for the jnode structure.
*/
node->st_mode = mode;
node->st_uid = geteuid();
400048b0: 40 00 01 9c call 40004f20 <geteuid>
400048b4: f8 26 20 14 st %i4, [ %i0 + 0x14 ]
node->st_gid = getegid();
400048b8: 40 00 01 94 call 40004f08 <getegid>
400048bc: d0 36 20 1c sth %o0, [ %i0 + 0x1c ]
/*
* Now set all the times.
*/
node->stat_atime = (time_t) tv.tv_sec;
400048c0: c4 1f bf f0 ldd [ %fp + -16 ], %g2
node->st_gid = getegid();
400048c4: d0 36 20 1e sth %o0, [ %i0 + 0x1e ]
node->stat_mtime = (time_t) tv.tv_sec;
node->stat_ctime = (time_t) tv.tv_sec;
return (*node_control->node_initialize)( node, arg );
400048c8: 92 10 00 1d mov %i5, %o1
node->stat_atime = (time_t) tv.tv_sec;
400048cc: c4 3e 20 20 std %g2, [ %i0 + 0x20 ]
node->stat_mtime = (time_t) tv.tv_sec;
400048d0: c4 3e 20 28 std %g2, [ %i0 + 0x28 ]
node->stat_ctime = (time_t) tv.tv_sec;
400048d4: c4 3e 20 30 std %g2, [ %i0 + 0x30 ]
return (*node_control->node_initialize)( node, arg );
400048d8: c2 06 60 04 ld [ %i1 + 4 ], %g1
400048dc: 9f c0 40 00 call %g1
400048e0: 90 10 00 18 mov %i0, %o0
}
400048e4: 81 c7 e0 08 ret
400048e8: 91 e8 00 08 restore %g0, %o0, %o0
errno = ENAMETOOLONG;
400048ec: 40 00 28 98 call 4000eb4c <__errno>
400048f0: b0 10 20 00 clr %i0
400048f4: 82 10 20 5b mov 0x5b, %g1
400048f8: c2 22 00 00 st %g1, [ %o0 ]
return NULL;
400048fc: 81 c7 e0 08 ret
40004900: 81 e8 00 00 restore
40003a7c <IMFS_initialize_support>:
{
40003a7c: 9d e3 bf a0 save %sp, -96, %sp
IMFS_fs_info_t *fs_info = mount_data->fs_info;
40003a80: fa 06 40 00 ld [ %i1 ], %i5
fs_info->mknod_controls = mount_data->mknod_controls;
40003a84: c2 06 60 08 ld [ %i1 + 8 ], %g1
40003a88: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
root_node = IMFS_initialize_node(
40003a8c: 9a 10 20 00 clr %o5
40003a90: d2 00 40 00 ld [ %g1 ], %o1
40003a94: 96 10 20 00 clr %o3
40003a98: 19 00 00 10 sethi %hi(0x4000), %o4
40003a9c: 90 10 00 1d mov %i5, %o0
40003aa0: 98 13 21 ed or %o4, 0x1ed, %o4
40003aa4: 15 10 00 64 sethi %hi(0x40019000), %o2
40003aa8: 40 00 03 76 call 40004880 <IMFS_initialize_node>
40003aac: 94 12 a0 60 or %o2, 0x60, %o2 ! 40019060 <rtems_test_name+0x1b0>
mt_entry->ops = mount_data->ops;
40003ab0: c2 06 60 04 ld [ %i1 + 4 ], %g1
loc->handlers = node->control->handlers;
40003ab4: c4 02 20 38 ld [ %o0 + 0x38 ], %g2
40003ab8: c2 26 20 0c st %g1, [ %i0 + 0xc ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
40003abc: 03 10 00 66 sethi %hi(0x40019800), %g1
40003ac0: 82 10 63 14 or %g1, 0x314, %g1 ! 40019b14 <IMFS_LIMITS_AND_OPTIONS>
mt_entry->fs_info = fs_info;
40003ac4: fa 26 20 08 st %i5, [ %i0 + 8 ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
40003ac8: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
40003acc: c4 00 80 00 ld [ %g2 ], %g2
mt_entry->mt_fs_root->location.node_access = root_node;
40003ad0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40003ad4: d0 20 60 08 st %o0, [ %g1 + 8 ]
40003ad8: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
IMFS_determine_bytes_per_block(
40003adc: 03 10 00 6c sethi %hi(0x4001b000), %g1
40003ae0: c6 00 63 a8 ld [ %g1 + 0x3a8 ], %g3 ! 4001b3a8 <imfs_rq_memfile_bytes_per_block>
if (bit_mask == requested_bytes_per_block) {
40003ae4: 80 a0 e0 10 cmp %g3, 0x10
40003ae8: 02 80 00 0e be 40003b20 <IMFS_initialize_support+0xa4>
40003aec: 80 a0 e0 0f cmp %g3, 0xf
if(bit_mask > requested_bytes_per_block)
40003af0: 04 80 00 0b ble 40003b1c <IMFS_initialize_support+0xa0> <== NEVER TAKEN
40003af4: 82 10 20 20 mov 0x20, %g1
40003af8: 84 10 20 05 mov 5, %g2
if (bit_mask == requested_bytes_per_block) {
40003afc: 80 a0 c0 01 cmp %g3, %g1
40003b00: 22 80 00 09 be,a 40003b24 <IMFS_initialize_support+0xa8>
40003b04: 03 10 00 7d sethi %hi(0x4001f400), %g1
if(bit_mask > requested_bytes_per_block)
40003b08: 26 80 00 06 bl,a 40003b20 <IMFS_initialize_support+0xa4> <== NEVER TAKEN
40003b0c: 86 10 20 80 mov 0x80, %g3
<== NOT EXECUTED
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
40003b10: 84 80 bf ff addcc %g2, -1, %g2
40003b14: 12 bf ff fa bne 40003afc <IMFS_initialize_support+0x80> <== ALWAYS TAKEN
40003b18: 83 28 60 01 sll %g1, 1, %g1
: default_bytes_per_block);
40003b1c: 86 10 20 80 mov 0x80, %g3
<== NOT EXECUTED
*dest_bytes_per_block = ((is_valid)
40003b20: 03 10 00 7d sethi %hi(0x4001f400), %g1
40003b24: c6 20 60 d8 st %g3, [ %g1 + 0xd8 ] ! 4001f4d8 <imfs_memfile_bytes_per_block>
}
40003b28: 81 c7 e0 08 ret
40003b2c: 91 e8 20 00 restore %g0, 0, %o0
4000d078 <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
4000d078: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
4000d07c: 7f ff e2 bb call 40005b68 <rtems_current_user_env_get>
4000d080: 01 00 00 00 nop
4000d084: da 02 20 08 ld [ %o0 + 8 ], %o5
4000d088: b2 2e 40 0d andn %i1, %o5, %i1
switch (mode & S_IFMT) {
4000d08c: 03 00 00 3c sethi %hi(0xf000), %g1
4000d090: 05 00 00 18 sethi %hi(0x6000), %g2
4000d094: 82 0e 40 01 and %i1, %g1, %g1
4000d098: 80 a0 40 02 cmp %g1, %g2
4000d09c: 02 80 00 0c be 4000d0cc <IMFS_make_generic_node+0x54>
4000d0a0: 94 10 20 78 mov 0x78, %o2
4000d0a4: 08 80 00 1d bleu 4000d118 <IMFS_make_generic_node+0xa0> <== ALWAYS TAKEN
4000d0a8: 05 00 00 04 sethi %hi(0x1000), %g2
4000d0ac: 05 00 00 20 sethi %hi(0x8000), %g2
<== NOT EXECUTED
4000d0b0: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4000d0b4: 02 80 00 06 be 4000d0cc <IMFS_make_generic_node+0x54>
<== NOT EXECUTED
4000d0b8: 05 00 00 30 sethi %hi(0xc000), %g2
<== NOT EXECUTED
4000d0bc: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4000d0c0: 12 80 00 1c bne 4000d130 <IMFS_make_generic_node+0xb8>
<== NOT EXECUTED
4000d0c4: 01 00 00 00 nop
<== NOT EXECUTED
if ( rv == 0 ) {
rtems_filesystem_eval_path_context_t ctx;
int eval_flags = RTEMS_FS_FOLLOW_LINK
| RTEMS_FS_MAKE
| RTEMS_FS_EXCLUSIVE;
const rtems_filesystem_location_info_t *currentloc =
4000d0c8: 94 10 20 78 mov 0x78, %o2 ! 78 <_TLS_Alignment+0x77>
<== NOT EXECUTED
4000d0cc: 92 10 00 18 mov %i0, %o1
4000d0d0: 7f ff e4 54 call 40006220 <rtems_filesystem_eval_path_start>
4000d0d4: 90 07 bf c8 add %fp, -56, %o0
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
4000d0d8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000d0dc: c2 00 60 0c ld [ %g1 + 0xc ], %g1
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
4000d0e0: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
4000d0e4: 03 10 00 12 sethi %hi(0x40004800), %g1
4000d0e8: 82 10 61 04 or %g1, 0x104, %g1 ! 40004904 <IMFS_node_clone>
4000d0ec: 80 a0 80 01 cmp %g2, %g1
4000d0f0: 02 80 00 16 be 4000d148 <IMFS_make_generic_node+0xd0>
4000d0f4: ba 10 00 08 mov %o0, %i5
IMFS_mtime_ctime_update( parent );
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
4000d0f8: 92 10 20 86 mov 0x86, %o1
4000d0fc: 90 07 bf c8 add %fp, -56, %o0
4000d100: 7f ff e3 8d call 40005f34 <rtems_filesystem_eval_path_error>
4000d104: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
4000d108: 7f ff e4 52 call 40006250 <rtems_filesystem_eval_path_cleanup>
4000d10c: 90 07 bf c8 add %fp, -56, %o0
}
return rv;
}
4000d110: 81 c7 e0 08 ret
4000d114: 81 e8 00 00 restore
switch (mode & S_IFMT) {
4000d118: 80 a0 40 02 cmp %g1, %g2
4000d11c: 02 bf ff eb be 4000d0c8 <IMFS_make_generic_node+0x50>
<== NEVER TAKEN
4000d120: 05 00 00 08 sethi %hi(0x2000), %g2
4000d124: 80 a0 40 02 cmp %g1, %g2
4000d128: 02 bf ff e9 be 4000d0cc <IMFS_make_generic_node+0x54>
4000d12c: 94 10 20 78 mov 0x78, %o2
errno = EINVAL;
4000d130: 40 00 06 87 call 4000eb4c <__errno>
4000d134: b0 10 3f ff mov -1, %i0
4000d138: 82 10 20 16 mov 0x16, %g1
4000d13c: c2 22 00 00 st %g1, [ %o0 ]
4000d140: 81 c7 e0 08 ret
4000d144: 81 e8 00 00 restore
IMFS_jnode_t *new_node = IMFS_create_node(
4000d148: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
4000d14c: 9a 10 00 19 mov %i1, %o5
4000d150: d8 07 bf d4 ld [ %fp + -44 ], %o4
4000d154: d6 07 bf d0 ld [ %fp + -48 ], %o3
4000d158: 94 10 20 48 mov 0x48, %o2
4000d15c: 92 10 00 1a mov %i2, %o1
4000d160: 7f ff ff a0 call 4000cfe0 <IMFS_create_node>
4000d164: b0 10 3f ff mov -1, %i0
if ( new_node != NULL ) {
4000d168: 80 a2 20 00 cmp %o0, 0
4000d16c: 02 bf ff e7 be 4000d108 <IMFS_make_generic_node+0x90>
4000d170: 01 00 00 00 nop
IMFS_jnode_t *parent = currentloc->node_access;
4000d174: fa 07 60 08 ld [ %i5 + 8 ], %i5
_Timecounter_Getbintime( &now );
4000d178: 7f ff ee 3b call 40008a64 <_Timecounter_Getbintime>
4000d17c: 90 07 bf b8 add %fp, -72, %o0
return now.sec;
4000d180: c4 1f bf b8 ldd [ %fp + -72 ], %g2
jnode->stat_mtime = now;
4000d184: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
int rv = 0;
4000d188: b0 10 20 00 clr %i0
jnode->stat_ctime = now;
4000d18c: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
rtems_filesystem_eval_path_cleanup( &ctx );
4000d190: 7f ff e4 30 call 40006250 <rtems_filesystem_eval_path_cleanup>
4000d194: 90 07 bf c8 add %fp, -56, %o0
}
4000d198: 81 c7 e0 08 ret
4000d19c: 81 e8 00 00 restore
40004500 <IMFS_memfile_write>:
{
40004500: 9d e3 bf 90 save %sp, -112, %sp
if ( last_byte > memfile->File.size ) {
40004504: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
last_byte = start + my_length;
40004508: 96 07 00 1a add %i4, %i2, %o3
if ( last_byte > memfile->File.size ) {
4000450c: 80 a0 40 0b cmp %g1, %o3
40004510: 0a 80 00 54 bcs 40004660 <IMFS_memfile_write+0x160>
40004514: a0 10 00 18 mov %i0, %l0
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
40004518: 23 10 00 7d sethi %hi(0x4001f400), %l1
4000451c: e4 04 60 d8 ld [ %l1 + 0xd8 ], %l2 ! 4001f4d8 <imfs_memfile_bytes_per_block>
40004520: bb 3c a0 1f sra %l2, 0x1f, %i5
40004524: 96 10 00 12 mov %l2, %o3
40004528: 94 10 00 1d mov %i5, %o2
4000452c: 92 10 00 1a mov %i2, %o1
40004530: 40 00 4d e0 call 40017cb0 <__moddi3>
40004534: 90 10 00 19 mov %i1, %o0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40004538: 94 10 00 1d mov %i5, %o2
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
4000453c: a6 10 00 09 mov %o1, %l3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40004540: 96 10 00 12 mov %l2, %o3
40004544: 92 10 00 1a mov %i2, %o1
40004548: 40 00 4d 4f call 40017a84 <__divdi3>
4000454c: 90 10 00 19 mov %i1, %o0
40004550: ba 10 00 12 mov %l2, %i5
40004554: b4 10 00 09 mov %o1, %i2
if ( start_offset ) {
40004558: 80 a4 e0 00 cmp %l3, 0
4000455c: 12 80 00 1a bne 400045c4 <IMFS_memfile_write+0xc4>
40004560: b0 10 20 00 clr %i0
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40004564: 80 a7 00 1d cmp %i4, %i5
40004568: 1a 80 00 0e bcc 400045a0 <IMFS_memfile_write+0xa0>
4000456c: 92 10 00 1a mov %i2, %o1
if ( my_length ) {
40004570: 10 80 00 29 b 40004614 <IMFS_memfile_write+0x114>
40004574: 80 a7 20 00 cmp %i4, 0
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
40004578: 40 00 2a e6 call 4000f110 <memcpy>
4000457c: d0 02 00 00 ld [ %o0 ], %o0
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40004580: c2 04 60 d8 ld [ %l1 + 0xd8 ], %g1
my_length -= to_copy;
40004584: b8 27 00 1d sub %i4, %i5, %i4
src += to_copy;
40004588: b6 06 c0 1d add %i3, %i5, %i3
block++;
4000458c: b4 06 a0 01 inc %i2
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40004590: 80 a0 40 1c cmp %g1, %i4
40004594: 18 80 00 1f bgu 40004610 <IMFS_memfile_write+0x110>
40004598: b0 06 00 1d add %i0, %i5, %i0
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
4000459c: 92 10 00 1a mov %i2, %o1
400045a0: 94 10 20 00 clr %o2
400045a4: 7f ff fd d4 call 40003cf4 <IMFS_memfile_get_block_pointer>
400045a8: 90 10 00 10 mov %l0, %o0
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
400045ac: 92 10 00 1b mov %i3, %o1
if ( !block_ptr )
400045b0: 80 a2 20 00 cmp %o0, 0
400045b4: 12 bf ff f1 bne 40004578 <IMFS_memfile_write+0x78>
<== ALWAYS TAKEN
400045b8: 94 10 00 1d mov %i5, %o2
}
400045bc: 81 c7 e0 08 ret
<== NOT EXECUTED
400045c0: 81 e8 00 00 restore
<== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
400045c4: 94 10 20 00 clr %o2
400045c8: 7f ff fd cb call 40003cf4 <IMFS_memfile_get_block_pointer>
400045cc: 90 10 00 10 mov %l0, %o0
if ( !block_ptr )
400045d0: 80 a2 20 00 cmp %o0, 0
400045d4: 02 bf ff fa be 400045bc <IMFS_memfile_write+0xbc>
<== NEVER TAKEN
400045d8: a4 24 80 13 sub %l2, %l3, %l2
400045dc: 80 a7 00 12 cmp %i4, %l2
400045e0: 18 80 00 37 bgu 400046bc <IMFS_memfile_write+0x1bc>
400045e4: b0 10 00 1c mov %i4, %i0
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
400045e8: d0 02 00 00 ld [ %o0 ], %o0
400045ec: 92 10 00 1b mov %i3, %o1
400045f0: 94 10 00 18 mov %i0, %o2
400045f4: 90 02 00 13 add %o0, %l3, %o0
400045f8: 40 00 2a c6 call 4000f110 <memcpy>
400045fc: b6 06 c0 18 add %i3, %i0, %i3
block++;
40004600: b4 06 a0 01 inc %i2
40004604: fa 04 60 d8 ld [ %l1 + 0xd8 ], %i5
my_length -= to_copy;
40004608: 10 bf ff d7 b 40004564 <IMFS_memfile_write+0x64>
4000460c: b8 27 00 18 sub %i4, %i0, %i4
if ( my_length ) {
40004610: 80 a7 20 00 cmp %i4, 0
40004614: 02 80 00 0c be 40004644 <IMFS_memfile_write+0x144>
40004618: 94 10 20 00 clr %o2
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
4000461c: 92 10 00 1a mov %i2, %o1
40004620: 7f ff fd b5 call 40003cf4 <IMFS_memfile_get_block_pointer>
40004624: 90 10 00 10 mov %l0, %o0
if ( !block_ptr )
40004628: 80 a2 20 00 cmp %o0, 0
4000462c: 02 bf ff e4 be 400045bc <IMFS_memfile_write+0xbc>
<== NEVER TAKEN
40004630: 94 10 00 1c mov %i4, %o2
memcpy( &(*block_ptr)[ 0 ], src, my_length );
40004634: d0 02 00 00 ld [ %o0 ], %o0
40004638: 92 10 00 1b mov %i3, %o1
4000463c: 40 00 2a b5 call 4000f110 <memcpy>
40004640: b0 06 00 1c add %i0, %i4, %i0
_Timecounter_Getbintime( &now );
40004644: 40 00 11 08 call 40008a64 <_Timecounter_Getbintime>
40004648: 90 07 bf f0 add %fp, -16, %o0
return now.sec;
4000464c: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_mtime = now;
40004650: c4 3c 20 28 std %g2, [ %l0 + 0x28 ]
jnode->stat_ctime = now;
40004654: c4 3c 20 30 std %g2, [ %l0 + 0x30 ]
}
40004658: 81 c7 e0 08 ret
4000465c: 81 e8 00 00 restore
bool zero_fill = start > memfile->File.size;
40004660: 80 a6 60 00 cmp %i1, 0
40004664: 04 80 00 0b ble 40004690 <IMFS_memfile_write+0x190>
<== ALWAYS TAKEN
40004668: 92 10 20 01 mov 1, %o1
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
4000466c: 94 10 20 00 clr %o2
<== NOT EXECUTED
40004670: 92 0a 60 01 and %o1, 1, %o1
40004674: 7f ff fe 49 call 40003f98 <IMFS_memfile_extend>
40004678: 90 10 00 10 mov %l0, %o0
if ( status )
4000467c: b0 92 20 00 orcc %o0, 0, %i0
40004680: 02 bf ff a7 be 4000451c <IMFS_memfile_write+0x1c>
40004684: 23 10 00 7d sethi %hi(0x4001f400), %l1
40004688: 81 c7 e0 08 ret
4000468c: 81 e8 00 00 restore
bool zero_fill = start > memfile->File.size;
40004690: 02 80 00 16 be 400046e8 <IMFS_memfile_write+0x1e8>
<== ALWAYS TAKEN
40004694: 80 a6 80 01 cmp %i2, %g1
40004698: 92 10 20 00 clr %o1
<== NOT EXECUTED
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
4000469c: 94 10 20 00 clr %o2
<== NOT EXECUTED
400046a0: 92 0a 60 01 and %o1, 1, %o1
400046a4: 7f ff fe 3d call 40003f98 <IMFS_memfile_extend>
400046a8: 90 10 00 10 mov %l0, %o0
if ( status )
400046ac: b0 92 20 00 orcc %o0, 0, %i0
400046b0: 02 bf ff 9b be 4000451c <IMFS_memfile_write+0x1c>
400046b4: 23 10 00 7d sethi %hi(0x4001f400), %l1
400046b8: 30 bf ff f4 b,a 40004688 <IMFS_memfile_write+0x188>
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
400046bc: d0 02 00 00 ld [ %o0 ], %o0
400046c0: b0 10 00 12 mov %l2, %i0
400046c4: 92 10 00 1b mov %i3, %o1
400046c8: 94 10 00 18 mov %i0, %o2
400046cc: 90 02 00 13 add %o0, %l3, %o0
400046d0: 40 00 2a 90 call 4000f110 <memcpy>
400046d4: b6 06 c0 18 add %i3, %i0, %i3
block++;
400046d8: b4 06 a0 01 inc %i2
400046dc: fa 04 60 d8 ld [ %l1 + 0xd8 ], %i5
my_length -= to_copy;
400046e0: 10 bf ff a1 b 40004564 <IMFS_memfile_write+0x64>
400046e4: b8 27 00 18 sub %i4, %i0, %i4
bool zero_fill = start > memfile->File.size;
400046e8: 18 bf ff e2 bgu 40004670 <IMFS_memfile_write+0x170>
400046ec: 94 10 20 00 clr %o2
400046f0: 10 bf ff ec b 400046a0 <IMFS_memfile_write+0x1a0>
400046f4: 92 10 20 00 clr %o1
4000480c <IMFS_mount>:
#endif
#include <rtems/imfs.h>
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
4000480c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40004810: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
<== NOT EXECUTED
40004814: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
return S_ISDIR( node->st_mode );
40004818: 07 00 00 3c sethi %hi(0xf000), %g3
4000481c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
40004820: 82 08 40 03 and %g1, %g3, %g1
if ( IMFS_is_directory( node ) ) {
40004824: 07 00 00 10 sethi %hi(0x4000), %g3
40004828: 80 a0 40 03 cmp %g1, %g3
4000482c: 12 80 00 0f bne 40004868 <IMFS_mount+0x5c>
<== NEVER TAKEN
40004830: 01 00 00 00 nop
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == NULL ) {
40004834: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
40004838: 80 a0 60 00 cmp %g1, 0
4000483c: 12 80 00 05 bne 40004850 <IMFS_mount+0x44>
<== NEVER TAKEN
40004840: 01 00 00 00 nop
dir->mt_fs = mt_entry;
40004844: f0 20 a0 4c st %i0, [ %g2 + 0x4c ]
40004848: 81 c7 e0 08 ret
4000484c: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = EBUSY;
40004850: 40 00 28 bf call 4000eb4c <__errno>
<== NOT EXECUTED
40004854: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004858: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
4000485c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004860: 81 c7 e0 08 ret
<== NOT EXECUTED
40004864: 81 e8 00 00 restore
<== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40004868: 40 00 28 b9 call 4000eb4c <__errno>
4000486c: b0 10 3f ff mov -1, %i0
40004870: 82 10 20 14 mov 0x14, %g1
40004874: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
40004878: 81 c7 e0 08 ret
4000487c: 81 e8 00 00 restore
40004904 <IMFS_node_clone>:
int IMFS_node_clone( rtems_filesystem_location_info_t *loc )
{
IMFS_jnode_t *node = loc->node_access;
40004904: c4 02 20 08 ld [ %o0 + 8 ], %g2
<== NOT EXECUTED
++node->reference_count;
40004908: c2 10 a0 18 lduh [ %g2 + 0x18 ], %g1
4000490c: 82 00 60 01 inc %g1
return 0;
}
40004910: 90 10 20 00 clr %o0
40004914: 81 c3 e0 08 retl
40004918: c2 30 a0 18 sth %g1, [ %g2 + 0x18 ]
4000491c <IMFS_node_destroy>:
void IMFS_node_destroy( IMFS_jnode_t *node )
{
4000491c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
IMFS_assert( node->reference_count == 0 );
(*node->control->node_destroy)( node );
40004920: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
<== NOT EXECUTED
40004924: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
40004928: 9f c0 40 00 call %g1
<== NOT EXECUTED
4000492c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
40004930: 81 c7 e0 08 ret
<== NOT EXECUTED
40004934: 81 e8 00 00 restore
<== NOT EXECUTED
4000497c <IMFS_node_destroy_default>:
void IMFS_node_destroy_default( IMFS_jnode_t *node )
{
4000497c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( ( node->flags & IMFS_NODE_FLAG_NAME_ALLOCATED ) != 0 ) {
40004980: c2 16 20 12 lduh [ %i0 + 0x12 ], %g1
<== NOT EXECUTED
40004984: 80 88 60 01 btst 1, %g1
<== NOT EXECUTED
40004988: 12 80 00 04 bne 40004998 <IMFS_node_destroy_default+0x1c>
<== NOT EXECUTED
4000498c: 01 00 00 00 nop
free( RTEMS_DECONST( char *, node->name ) );
}
free( node );
40004990: 40 00 01 3c call 40004e80 <free>
40004994: 81 e8 00 00 restore
free( RTEMS_DECONST( char *, node->name ) );
40004998: 40 00 01 3a call 40004e80 <free>
4000499c: d0 06 20 0c ld [ %i0 + 0xc ], %o0
free( node );
400049a0: 40 00 01 38 call 40004e80 <free>
400049a4: 81 e8 00 00 restore
40003b30 <IMFS_node_initialize_default>:
IMFS_jnode_t *node,
void *arg
)
{
return node;
}
40003b30: 81 c3 e0 08 retl
<== NOT EXECUTED
40003b34: 01 00 00 00 nop
40004974 <IMFS_node_remove_default>:
IMFS_jnode_t *IMFS_node_remove_default(
IMFS_jnode_t *node
)
{
return node;
}
40004974: 81 c3 e0 08 retl
<== NOT EXECUTED
40004978: 01 00 00 00 nop
40003790 <IMFS_node_remove_directory>:
{
return dir->mt_fs != NULL;
}
IMFS_jnode_t *IMFS_node_remove_directory( IMFS_jnode_t *node )
{
40003790: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( !rtems_chain_is_empty( &dir->Entries ) ) {
40003794: c4 06 20 40 ld [ %i0 + 0x40 ], %g2
<== NOT EXECUTED
return &the_chain->Tail.Node;
40003798: 82 06 20 44 add %i0, 0x44, %g1
<== NOT EXECUTED
4000379c: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
400037a0: 12 80 00 0c bne 400037d0 <IMFS_node_remove_directory+0x40>
<== NOT EXECUTED
400037a4: 01 00 00 00 nop
errno = ENOTEMPTY;
dir = NULL;
} else if ( IMFS_is_mount_point( dir ) ) {
400037a8: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
400037ac: 80 a0 60 00 cmp %g1, 0
400037b0: 02 80 00 0c be 400037e0 <IMFS_node_remove_directory+0x50> <== ALWAYS TAKEN
400037b4: 01 00 00 00 nop
errno = EBUSY;
400037b8: 40 00 2c e5 call 4000eb4c <__errno>
<== NOT EXECUTED
400037bc: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
400037c0: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
400037c4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
dir = NULL;
}
return &dir->Node;
}
400037c8: 81 c7 e0 08 ret
<== NOT EXECUTED
400037cc: 81 e8 00 00 restore
<== NOT EXECUTED
errno = ENOTEMPTY;
400037d0: 40 00 2c df call 4000eb4c <__errno>
400037d4: b0 10 20 00 clr %i0
400037d8: 82 10 20 5a mov 0x5a, %g1
400037dc: c2 22 00 00 st %g1, [ %o0 ]
400037e0: 81 c7 e0 08 ret
400037e4: 81 e8 00 00 restore
40004c44 <IMFS_readlink>:
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40004c44: 80 a2 a0 00 cmp %o2, 0
<== NOT EXECUTED
40004c48: 02 80 00 16 be 40004ca0 <IMFS_readlink+0x5c>
<== NOT EXECUTED
40004c4c: c6 02 20 08 ld [ %o0 + 8 ], %g3
40004c50: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
40004c54: c4 48 40 00 ldsb [ %g1 ], %g2
40004c58: 90 10 20 00 clr %o0
40004c5c: 80 a0 a0 00 cmp %g2, 0
40004c60: 12 80 00 07 bne 40004c7c <IMFS_readlink+0x38>
<== ALWAYS TAKEN
40004c64: c2 08 40 00 ldub [ %g1 ], %g1
40004c68: 30 80 00 0c b,a 40004c98 <IMFS_readlink+0x54>
<== NOT EXECUTED
40004c6c: c4 48 40 08 ldsb [ %g1 + %o0 ], %g2
40004c70: 80 a0 a0 00 cmp %g2, 0
40004c74: 02 80 00 07 be 40004c90 <IMFS_readlink+0x4c>
40004c78: c2 08 40 08 ldub [ %g1 + %o0 ], %g1
buf[i] = sym_link->name[i];
40004c7c: c2 2a 40 08 stb %g1, [ %o1 + %o0 ]
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40004c80: 90 02 20 01 inc %o0
40004c84: 80 a2 80 08 cmp %o2, %o0
40004c88: 32 bf ff f9 bne,a 40004c6c <IMFS_readlink+0x28>
40004c8c: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
}
40004c90: 81 c3 e0 08 retl
40004c94: 01 00 00 00 nop
40004c98: 81 c3 e0 08 retl
<== NOT EXECUTED
40004c9c: 01 00 00 00 nop
<== NOT EXECUTED
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40004ca0: 81 c3 e0 08 retl
<== NOT EXECUTED
40004ca4: 90 10 20 00 clr %o0 ! 0 <PROM_START>
<== NOT EXECUTED
400049a8 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
400049a8: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
IMFS_jnode_t *node = oldloc->node_access;
400049ac: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
/*
* FIXME: Due to insufficient checks we can create inaccessible nodes with
* this operation.
*/
if ( node->Parent == NULL ) {
400049b0: c2 07 60 08 ld [ %i5 + 8 ], %g1
<== NOT EXECUTED
400049b4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400049b8: 02 80 00 36 be 40004a90 <IMFS_rename+0xe8>
<== NOT EXECUTED
400049bc: f4 06 a0 08 ld [ %i2 + 8 ], %i2
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( namelen >= IMFS_NAME_MAX ) {
400049c0: 80 a7 20 fe cmp %i4, 0xfe
400049c4: 18 80 00 27 bgu 40004a60 <IMFS_rename+0xb8>
400049c8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
}
allocated_name = malloc( namelen );
400049cc: 40 00 02 3c call 400052bc <malloc>
400049d0: 90 10 00 1c mov %i4, %o0
if ( allocated_name == NULL ) {
400049d4: b2 92 20 00 orcc %o0, 0, %i1
400049d8: 02 80 00 28 be 40004a78 <IMFS_rename+0xd0>
<== NEVER TAKEN
400049dc: 94 10 00 1c mov %i4, %o2
rtems_set_errno_and_return_minus_one( ENOMEM );
}
memcpy( allocated_name, name, namelen );
400049e0: 40 00 29 cc call 4000f110 <memcpy>
400049e4: 92 10 00 1b mov %i3, %o1
if ( ( node->flags & IMFS_NODE_FLAG_NAME_ALLOCATED ) != 0 ) {
400049e8: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1
400049ec: 80 88 60 01 btst 1, %g1
400049f0: 12 80 00 18 bne 40004a50 <IMFS_rename+0xa8>
400049f4: 01 00 00 00 nop
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
400049f8: c6 07 40 00 ld [ %i5 ], %g3
previous = the_node->previous;
400049fc: c4 07 60 04 ld [ %i5 + 4 ], %g2
free( RTEMS_DECONST( char *, node->name ) );
}
node->name = allocated_name;
40004a00: f2 27 60 0c st %i1, [ %i5 + 0xc ]
node->namelen = namelen;
node->flags |= IMFS_NODE_FLAG_NAME_ALLOCATED;
40004a04: 82 10 60 01 or %g1, 1, %g1
node->namelen = namelen;
40004a08: f8 37 60 10 sth %i4, [ %i5 + 0x10 ]
return &the_chain->Tail.Node;
40004a0c: 88 06 a0 44 add %i2, 0x44, %g4
node->flags |= IMFS_NODE_FLAG_NAME_ALLOCATED;
40004a10: c2 37 60 12 sth %g1, [ %i5 + 0x12 ]
_Timecounter_Getbintime( &now );
40004a14: 90 07 bf f0 add %fp, -16, %o0
next->previous = previous;
40004a18: c4 20 e0 04 st %g2, [ %g3 + 4 ]
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
return 0;
40004a1c: b0 10 20 00 clr %i0
previous->next = next;
40004a20: c6 20 80 00 st %g3, [ %g2 ]
Chain_Node *old_last;
_Assert( _Chain_Is_node_off_chain( the_node ) );
tail = _Chain_Tail( the_chain );
old_last = tail->previous;
40004a24: c2 06 a0 48 ld [ %i2 + 0x48 ], %g1
entry_node->Parent = dir_node;
40004a28: f4 27 60 08 st %i2, [ %i5 + 8 ]
the_node->next = tail;
40004a2c: c8 27 40 00 st %g4, [ %i5 ]
tail->previous = the_node;
40004a30: fa 26 a0 48 st %i5, [ %i2 + 0x48 ]
old_last->next = the_node;
40004a34: fa 20 40 00 st %i5, [ %g1 ]
_Timecounter_Getbintime( &now );
40004a38: 40 00 10 0b call 40008a64 <_Timecounter_Getbintime>
40004a3c: c2 27 60 04 st %g1, [ %i5 + 4 ]
return now.sec;
40004a40: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_ctime = _IMFS_get_time();
40004a44: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
}
40004a48: 81 c7 e0 08 ret
40004a4c: 81 e8 00 00 restore
free( RTEMS_DECONST( char *, node->name ) );
40004a50: 40 00 01 0c call 40004e80 <free>
40004a54: d0 07 60 0c ld [ %i5 + 0xc ], %o0
40004a58: 10 bf ff e8 b 400049f8 <IMFS_rename+0x50>
40004a5c: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
40004a60: 40 00 28 3b call 4000eb4c <__errno>
40004a64: b0 10 3f ff mov -1, %i0
40004a68: 82 10 20 5b mov 0x5b, %g1
40004a6c: c2 22 00 00 st %g1, [ %o0 ]
40004a70: 81 c7 e0 08 ret
40004a74: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( ENOMEM );
40004a78: 40 00 28 35 call 4000eb4c <__errno>
<== NOT EXECUTED
40004a7c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004a80: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40004a84: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004a88: 81 c7 e0 08 ret
<== NOT EXECUTED
40004a8c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
40004a90: 40 00 28 2f call 4000eb4c <__errno>
<== NOT EXECUTED
40004a94: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004a98: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40004a9c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004aa0: 81 c7 e0 08 ret
<== NOT EXECUTED
40004aa4: 81 e8 00 00 restore
<== NOT EXECUTED
40004aa8 <IMFS_rmnod>:
int IMFS_rmnod(
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
40004aa8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int rv = 0;
IMFS_jnode_t *node = loc->node_access;
40004aac: d0 06 60 08 ld [ %i1 + 8 ], %o0
<== NOT EXECUTED
node = (*node->control->node_remove)( node );
40004ab0: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
<== NOT EXECUTED
40004ab4: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
40004ab8: 9f c0 40 00 call %g1
<== NOT EXECUTED
40004abc: 01 00 00 00 nop
if ( node != NULL ) {
40004ac0: 80 a2 20 00 cmp %o0, 0
40004ac4: 22 80 00 11 be,a 40004b08 <IMFS_rmnod+0x60>
40004ac8: b0 10 3f ff mov -1, %i0
--node->reference_count;
40004acc: c4 12 20 18 lduh [ %o0 + 0x18 ], %g2
--node->st_nlink;
40004ad0: c2 12 20 1a lduh [ %o0 + 0x1a ], %g1
40004ad4: 82 00 7f ff add %g1, -1, %g1
--node->reference_count;
40004ad8: 84 00 bf ff add %g2, -1, %g2
--node->st_nlink;
40004adc: c2 32 20 1a sth %g1, [ %o0 + 0x1a ]
--node->reference_count;
40004ae0: c4 32 20 18 sth %g2, [ %o0 + 0x18 ]
if ( node->Parent != NULL ) {
40004ae4: c2 02 20 08 ld [ %o0 + 8 ], %g1
40004ae8: 80 a0 60 00 cmp %g1, 0
40004aec: 02 80 00 07 be 40004b08 <IMFS_rmnod+0x60>
40004af0: b0 10 20 00 clr %i0
node->Parent = NULL;
40004af4: c0 22 20 08 clr [ %o0 + 8 ]
next = the_node->next;
40004af8: c4 02 00 00 ld [ %o0 ], %g2
previous = the_node->previous;
40004afc: c2 02 20 04 ld [ %o0 + 4 ], %g1
next->previous = previous;
40004b00: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40004b04: c4 20 40 00 st %g2, [ %g1 ]
40004b08: 81 c7 e0 08 ret
40004b0c: 81 e8 00 00 restore
} else {
rv = -1;
}
return rv;
}
40004b10: 81 c7 e0 08 ret
<== NOT EXECUTED
40004b14: 81 e8 00 00 restore
<== NOT EXECUTED
40004b40 <IMFS_stat>:
int IMFS_stat(
const rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
40004b40: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
const IMFS_fs_info_t *fs_info = loc->mt_entry->fs_info;
40004b44: c4 06 20 14 ld [ %i0 + 0x14 ], %g2
<== NOT EXECUTED
IMFS_jnode_t *the_jnode = loc->node_access;
40004b48: c2 06 20 08 ld [ %i0 + 8 ], %g1
static inline dev_t rtems_filesystem_make_dev_t_from_pointer(
const void *pointer
)
{
uint64_t temp = (((uint64_t) 1) << 63) | (((uintptr_t) pointer) >> 1);
40004b4c: c4 00 a0 08 ld [ %g2 + 8 ], %g2
buf->st_dev = rtems_filesystem_make_dev_t_from_pointer( fs_info );
buf->st_mode = the_jnode->st_mode;
40004b50: d6 00 60 14 ld [ %g1 + 0x14 ], %o3
buf->st_nlink = the_jnode->st_nlink;
40004b54: de 10 60 1a lduh [ %g1 + 0x1a ], %o7
buf->st_ino = IMFS_node_to_ino( the_jnode );
buf->st_uid = the_jnode->st_uid;
40004b58: c8 10 60 1c lduh [ %g1 + 0x1c ], %g4
buf->st_gid = the_jnode->st_gid;
40004b5c: c6 10 60 1e lduh [ %g1 + 0x1e ], %g3
buf->st_atime = the_jnode->stat_atime;
40004b60: d8 18 60 20 ldd [ %g1 + 0x20 ], %o4
buf->st_mtime = the_jnode->stat_mtime;
40004b64: f4 18 60 28 ldd [ %g1 + 0x28 ], %i2
buf->st_ctime = the_jnode->stat_ctime;
40004b68: f8 18 60 30 ldd [ %g1 + 0x30 ], %i4
40004b6c: 85 30 a0 01 srl %g2, 1, %g2
buf->st_dev = rtems_filesystem_make_dev_t_from_pointer( fs_info );
40004b70: c4 26 60 04 st %g2, [ %i1 + 4 ]
40004b74: 05 20 00 00 sethi %hi(0x80000000), %g2
buf->st_mode = the_jnode->st_mode;
40004b78: d6 26 60 0c st %o3, [ %i1 + 0xc ]
buf->st_dev = rtems_filesystem_make_dev_t_from_pointer( fs_info );
40004b7c: c4 26 40 00 st %g2, [ %i1 ]
buf->st_nlink = the_jnode->st_nlink;
40004b80: de 36 60 10 sth %o7, [ %i1 + 0x10 ]
buf->st_ino = IMFS_node_to_ino( the_jnode );
40004b84: c2 26 60 08 st %g1, [ %i1 + 8 ]
buf->st_uid = the_jnode->st_uid;
40004b88: c8 36 60 12 sth %g4, [ %i1 + 0x12 ]
buf->st_gid = the_jnode->st_gid;
40004b8c: c6 36 60 14 sth %g3, [ %i1 + 0x14 ]
buf->st_atime = the_jnode->stat_atime;
40004b90: d8 3e 60 28 std %o4, [ %i1 + 0x28 ]
buf->st_mtime = the_jnode->stat_mtime;
40004b94: f4 3e 60 38 std %i2, [ %i1 + 0x38 ]
buf->st_ctime = the_jnode->stat_ctime;
40004b98: f8 3e 60 48 std %i4, [ %i1 + 0x48 ]
return 0;
}
40004b9c: 81 c7 e0 08 ret
40004ba0: 91 e8 20 00 restore %g0, 0, %o0
40004b18 <IMFS_stat_file>:
struct stat *buf
)
{
const IMFS_file_t *file = loc->node_access;
buf->st_size = file->File.size;
40004b18: c2 02 20 08 ld [ %o0 + 8 ], %g1
<== NOT EXECUTED
40004b1c: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
<== NOT EXECUTED
buf->st_blksize = imfs_memfile_bytes_per_block;
40004b20: 03 10 00 7d sethi %hi(0x4001f400), %g1
<== NOT EXECUTED
40004b24: c4 00 60 d8 ld [ %g1 + 0xd8 ], %g2 ! 4001f4d8 <imfs_memfile_bytes_per_block>
<== NOT EXECUTED
buf->st_size = file->File.size;
40004b28: c0 22 60 20 clr [ %o1 + 0x20 ]
<== NOT EXECUTED
40004b2c: c6 22 60 24 st %g3, [ %o1 + 0x24 ]
<== NOT EXECUTED
buf->st_blksize = imfs_memfile_bytes_per_block;
40004b30: c4 22 60 58 st %g2, [ %o1 + 0x58 ]
<== NOT EXECUTED
return IMFS_stat( loc, buf );
40004b34: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40004b38: 40 00 00 02 call 40004b40 <IMFS_stat>
<== NOT EXECUTED
40004b3c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40004ca8 <IMFS_unmount>:
#endif
#include <rtems/imfs.h>
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40004ca8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40004cac: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
<== NOT EXECUTED
40004cb0: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
return S_ISDIR( node->st_mode );
40004cb4: 07 00 00 3c sethi %hi(0xf000), %g3
<== NOT EXECUTED
40004cb8: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
<== NOT EXECUTED
40004cbc: 82 08 40 03 and %g1, %g3, %g1
<== NOT EXECUTED
if ( IMFS_is_directory( node ) ) {
40004cc0: 07 00 00 10 sethi %hi(0x4000), %g3
<== NOT EXECUTED
40004cc4: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
40004cc8: 12 80 00 0f bne 40004d04 <IMFS_unmount+0x5c>
<== NOT EXECUTED
40004ccc: 01 00 00 00 nop
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == mt_entry ) {
40004cd0: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
40004cd4: 80 a0 40 18 cmp %g1, %i0
40004cd8: 12 80 00 05 bne 40004cec <IMFS_unmount+0x44>
<== NEVER TAKEN
40004cdc: 01 00 00 00 nop
dir->mt_fs = NULL;
40004ce0: c0 20 a0 4c clr [ %g2 + 0x4c ]
40004ce4: 81 c7 e0 08 ret
40004ce8: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = EINVAL;
40004cec: 40 00 27 98 call 4000eb4c <__errno>
<== NOT EXECUTED
40004cf0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004cf4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40004cf8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004cfc: 81 c7 e0 08 ret
<== NOT EXECUTED
40004d00: 81 e8 00 00 restore
<== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40004d04: 40 00 27 92 call 4000eb4c <__errno>
<== NOT EXECUTED
40004d08: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004d0c: 82 10 20 14 mov 0x14, %g1
<== NOT EXECUTED
40004d10: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
40004d14: 81 c7 e0 08 ret
<== NOT EXECUTED
40004d18: 81 e8 00 00 restore
<== NOT EXECUTED
40004d1c <IMFS_utime>:
int IMFS_utime(
const rtems_filesystem_location_info_t *loc,
time_t actime,
time_t modtime
)
{
40004d1c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) loc->node_access;
40004d20: fa 06 20 08 ld [ %i0 + 8 ], %i5
<== NOT EXECUTED
{
40004d24: 84 10 00 1b mov %i3, %g2
<== NOT EXECUTED
40004d28: b0 10 00 19 mov %i1, %i0
<== NOT EXECUTED
40004d2c: 86 10 00 1c mov %i4, %g3
<== NOT EXECUTED
40004d30: b2 10 00 1a mov %i2, %i1
<== NOT EXECUTED
the_jnode->stat_atime = actime;
the_jnode->stat_mtime = modtime;
40004d34: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
<== NOT EXECUTED
the_jnode->stat_ctime = time( NULL );
40004d38: 90 10 20 00 clr %o0
<== NOT EXECUTED
the_jnode->stat_atime = actime;
40004d3c: f0 3f 60 20 std %i0, [ %i5 + 0x20 ]
<== NOT EXECUTED
the_jnode->stat_ctime = time( NULL );
40004d40: 40 00 2b 38 call 4000fa20 <time>
<== NOT EXECUTED
40004d44: b0 10 20 00 clr %i0
<== NOT EXECUTED
40004d48: d0 3f 60 30 std %o0, [ %i5 + 0x30 ]
return 0;
}
40004d4c: 81 c7 e0 08 ret
40004d50: 81 e8 00 00 restore
4000cf78 <device_close>:
}
int device_close(
rtems_libio_t *iop
)
{
4000cf78: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_close(
4000cf7c: d4 00 60 44 ld [ %g1 + 0x44 ], %o2
<== NOT EXECUTED
4000cf80: d2 00 60 40 ld [ %g1 + 0x40 ], %o1
<== NOT EXECUTED
4000cf84: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000cf88: 40 00 01 a4 call 4000d618 <rtems_deviceio_close>
<== NOT EXECUTED
4000cf8c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000cfd8 <device_ftruncate>:
rtems_libio_t *iop,
off_t length
)
{
return 0;
}
4000cfd8: 81 c3 e0 08 retl
<== NOT EXECUTED
4000cfdc: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000cfc0 <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
ioctl_command_t command,
void *buffer
)
{
4000cfc0: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_control(
4000cfc4: d8 00 60 44 ld [ %g1 + 0x44 ], %o4
<== NOT EXECUTED
4000cfc8: d6 00 60 40 ld [ %g1 + 0x40 ], %o3
<== NOT EXECUTED
4000cfcc: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000cfd0: 40 00 01 d6 call 4000d728 <rtems_deviceio_control>
<== NOT EXECUTED
4000cfd4: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000cf90 <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
4000cf90: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_read(
4000cf94: d8 00 60 44 ld [ %g1 + 0x44 ], %o4
<== NOT EXECUTED
4000cf98: d6 00 60 40 ld [ %g1 + 0x40 ], %o3
<== NOT EXECUTED
4000cf9c: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000cfa0: 40 00 01 aa call 4000d648 <rtems_deviceio_read>
<== NOT EXECUTED
4000cfa4: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000cfa8 <device_write>:
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
4000cfa8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_write(
4000cfac: d8 00 60 44 ld [ %g1 + 0x44 ], %o4
<== NOT EXECUTED
4000cfb0: d6 00 60 40 ld [ %g1 + 0x40 ], %o3
<== NOT EXECUTED
4000cfb4: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000cfb8: 40 00 01 c0 call 4000d6b8 <rtems_deviceio_write>
<== NOT EXECUTED
4000cfbc: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000d7e8 <fifo_open>:
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000d7e8: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
_Mutex_Acquire( mutex );
4000d7ec: 37 10 00 6d sethi %hi(0x4001b400), %i3
<== NOT EXECUTED
4000d7f0: 7f ff ee 18 call 40009050 <_Mutex_Acquire>
<== NOT EXECUTED
4000d7f4: 90 16 e0 20 or %i3, 0x20, %o0 ! 4001b420 <pipe_mutex>
<== NOT EXECUTED
pipe = *pipep;
4000d7f8: fa 06 00 00 ld [ %i0 ], %i5
if (pipe == NULL) {
4000d7fc: 80 a7 60 00 cmp %i5, 0
4000d800: 02 80 00 1a be 4000d868 <fifo_open+0x80>
4000d804: b8 10 00 18 mov %i0, %i4
4000d808: 7f ff ee 12 call 40009050 <_Mutex_Acquire>
4000d80c: 90 07 60 28 add %i5, 0x28, %o0
if (*pipep == NULL) {
4000d810: c2 07 00 00 ld [ %i4 ], %g1
4000d814: 80 a0 60 00 cmp %g1, 0
4000d818: 22 80 00 4c be,a 4000d948 <fifo_open+0x160>
4000d81c: fa 27 00 00 st %i5, [ %i4 ]
_Mutex_Release( mutex );
4000d820: 7f ff ee 28 call 400090c0 <_Mutex_Release>
4000d824: 90 16 e0 20 or %i3, 0x20, %o0
4000d828: c2 06 60 08 ld [ %i1 + 8 ], %g1
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
4000d82c: fa 07 00 00 ld [ %i4 ], %i5
switch (LIBIO_ACCMODE(iop)) {
4000d830: 82 08 60 06 and %g1, 6, %g1
4000d834: 80 a0 60 04 cmp %g1, 4
4000d838: 02 80 00 4c be 4000d968 <fifo_open+0x180>
4000d83c: b6 07 60 28 add %i5, 0x28, %i3
4000d840: 80 a0 60 06 cmp %g1, 6
4000d844: 02 80 00 97 be 4000daa0 <fifo_open+0x2b8>
4000d848: 80 a0 60 02 cmp %g1, 2
4000d84c: 22 80 00 74 be,a 4000da1c <fifo_open+0x234>
<== ALWAYS TAKEN
4000d850: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
return 0;
4000d854: b0 10 20 00 clr %i0
<== NOT EXECUTED
4000d858: 7f ff ee 1a call 400090c0 <_Mutex_Release>
4000d85c: 90 10 00 1b mov %i3, %o0
4000d860: 81 c7 e0 08 ret
4000d864: 81 e8 00 00 restore
pipe = malloc(sizeof(pipe_control_t));
4000d868: 7f ff df 29 call 4000550c <malloc>
4000d86c: 90 10 20 44 mov 0x44, %o0
if (pipe == NULL)
4000d870: ba 92 20 00 orcc %o0, 0, %i5
4000d874: 02 80 00 be be 4000db6c <fifo_open+0x384>
<== NEVER TAKEN
4000d878: 94 10 20 3c mov 0x3c, %o2
memset(pipe, 0, sizeof(pipe_control_t));
4000d87c: 92 10 20 00 clr %o1
4000d880: 40 00 0c e2 call 40010c08 <memset>
4000d884: 90 07 60 08 add %i5, 8, %o0
pipe->Size = PIPE_BUF;
4000d888: 82 10 22 00 mov 0x200, %g1
4000d88c: c2 27 60 04 st %g1, [ %i5 + 4 ]
pipe->Buffer = malloc(pipe->Size);
4000d890: 7f ff df 1f call 4000550c <malloc>
4000d894: 90 10 22 00 mov 0x200, %o0
if (! pipe->Buffer)
4000d898: 80 a2 20 00 cmp %o0, 0
4000d89c: 02 80 00 ad be 4000db50 <fifo_open+0x368>
<== NEVER TAKEN
4000d8a0: d0 27 40 00 st %o0, [ %i5 ]
rtems_build_name ('P', 'I', 'r', c),
4000d8a4: 35 10 00 6d sethi %hi(0x4001b400), %i2
if (rtems_barrier_create(
4000d8a8: 03 14 12 5c sethi %hi(0x50497000), %g1
rtems_build_name ('P', 'I', 'r', c),
4000d8ac: d0 4e a0 1c ldsb [ %i2 + 0x1c ], %o0
if (rtems_barrier_create(
4000d8b0: 82 10 62 00 or %g1, 0x200, %g1
4000d8b4: 96 07 60 3c add %i5, 0x3c, %o3
4000d8b8: 94 10 20 00 clr %o2
4000d8bc: 92 10 20 00 clr %o1
4000d8c0: 40 00 03 e3 call 4000e84c <rtems_barrier_create>
4000d8c4: 90 12 00 01 or %o0, %g1, %o0
4000d8c8: 80 a2 20 00 cmp %o0, 0
4000d8cc: 12 80 00 9f bne 4000db48 <fifo_open+0x360>
4000d8d0: d0 4e a0 1c ldsb [ %i2 + 0x1c ], %o0
if (rtems_barrier_create(
4000d8d4: 03 14 12 5d sethi %hi(0x50497400), %g1
4000d8d8: 82 10 63 00 or %g1, 0x300, %g1 ! 50497700 <RAM_END+0x10097700>
4000d8dc: 96 07 60 40 add %i5, 0x40, %o3
4000d8e0: 94 10 20 00 clr %o2
4000d8e4: 92 10 20 00 clr %o1
4000d8e8: 40 00 03 d9 call 4000e84c <rtems_barrier_create>
4000d8ec: 90 12 00 01 or %o0, %g1, %o0
4000d8f0: 80 a2 20 00 cmp %o0, 0
4000d8f4: 12 80 00 93 bne 4000db40 <fifo_open+0x358>
4000d8f8: 03 10 00 65 sethi %hi(0x40019400), %g1
static __inline void
_Mutex_Initialize_named(struct _Mutex_Control *_mutex, const char *_name)
{
struct _Mutex_Control _init = _MUTEX_NAMED_INITIALIZER(_name);
*_mutex = _init;
4000d8fc: c0 27 60 28 clr [ %i5 + 0x28 ]
4000d900: 82 10 63 c8 or %g1, 0x3c8, %g1
4000d904: c0 27 60 2c clr [ %i5 + 0x2c ]
4000d908: c2 27 60 38 st %g1, [ %i5 + 0x38 ]
4000d90c: c0 27 60 30 clr [ %i5 + 0x30 ]
4000d910: c0 27 60 34 clr [ %i5 + 0x34 ]
if (c ++ == 'z')
4000d914: c4 4e a0 1c ldsb [ %i2 + 0x1c ], %g2
4000d918: 80 a0 a0 7a cmp %g2, 0x7a
4000d91c: 02 80 00 3d be 4000da10 <fifo_open+0x228>
4000d920: c2 0e a0 1c ldub [ %i2 + 0x1c ], %g1
4000d924: 82 00 60 01 inc %g1
_Mutex_Acquire( mutex );
4000d928: 90 07 60 28 add %i5, 0x28, %o0
4000d92c: 7f ff ed c9 call 40009050 <_Mutex_Acquire>
4000d930: c2 2e a0 1c stb %g1, [ %i2 + 0x1c ]
if (*pipep == NULL) {
4000d934: c2 07 00 00 ld [ %i4 ], %g1
4000d938: 80 a0 60 00 cmp %g1, 0
4000d93c: 12 bf ff b9 bne 4000d820 <fifo_open+0x38>
<== NEVER TAKEN
4000d940: 01 00 00 00 nop
*pipep = pipe;
4000d944: fa 27 00 00 st %i5, [ %i4 ]
_Mutex_Release( mutex );
4000d948: 7f ff ed de call 400090c0 <_Mutex_Release>
4000d94c: 90 16 e0 20 or %i3, 0x20, %o0
4000d950: c2 06 60 08 ld [ %i1 + 8 ], %g1
pipe = *pipep;
4000d954: fa 07 00 00 ld [ %i4 ], %i5
switch (LIBIO_ACCMODE(iop)) {
4000d958: 82 08 60 06 and %g1, 6, %g1
4000d95c: 80 a0 60 04 cmp %g1, 4
4000d960: 12 bf ff b8 bne 4000d840 <fifo_open+0x58>
4000d964: b6 07 60 28 add %i5, 0x28, %i3
if (pipe->Writers ++ == 0)
4000d968: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
pipe->writerCounter ++;
4000d96c: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000d970: 82 00 60 01 inc %g1
if (pipe->Writers ++ == 0)
4000d974: 86 00 a0 01 add %g2, 1, %g3
pipe->writerCounter ++;
4000d978: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
4000d97c: 80 a0 a0 00 cmp %g2, 0
4000d980: 02 80 00 61 be 4000db04 <fifo_open+0x31c>
<== ALWAYS TAKEN
4000d984: c6 27 60 14 st %g3, [ %i5 + 0x14 ]
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4000d988: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
<== NOT EXECUTED
4000d98c: 80 a0 60 00 cmp %g1, 0
4000d990: 12 bf ff b2 bne 4000d858 <fifo_open+0x70>
4000d994: b0 10 20 00 clr %i0
4000d998: c2 06 60 08 ld [ %i1 + 8 ], %g1
4000d99c: 80 88 60 01 btst 1, %g1
4000d9a0: 32 80 00 55 bne,a 4000daf4 <fifo_open+0x30c>
4000d9a4: 90 10 00 1b mov %i3, %o0
if (pipe->Readers == 0) {
4000d9a8: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000d9ac: 80 a0 60 00 cmp %g1, 0
4000d9b0: 12 bf ff aa bne 4000d858 <fifo_open+0x70>
<== NEVER TAKEN
4000d9b4: b0 10 20 00 clr %i0
prevCounter = pipe->readerCounter;
4000d9b8: 10 80 00 08 b 4000d9d8 <fifo_open+0x1f0>
4000d9bc: f4 07 60 20 ld [ %i5 + 0x20 ], %i2
_Mutex_Acquire( mutex );
4000d9c0: 7f ff ed a4 call 40009050 <_Mutex_Acquire>
4000d9c4: 01 00 00 00 nop
} while (prevCounter == pipe->readerCounter);
4000d9c8: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000d9cc: 80 a0 40 1a cmp %g1, %i2
4000d9d0: 12 bf ff a2 bne 4000d858 <fifo_open+0x70>
<== ALWAYS TAKEN
4000d9d4: b0 10 20 00 clr %i0
_Mutex_Release( mutex );
4000d9d8: 7f ff ed ba call 400090c0 <_Mutex_Release>
4000d9dc: 90 10 00 1b mov %i3, %o0
if (! PIPE_WRITEWAIT(pipe))
4000d9e0: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
4000d9e4: 40 00 04 06 call 4000e9fc <rtems_barrier_wait>
4000d9e8: 92 10 20 00 clr %o1
4000d9ec: 80 a2 20 00 cmp %o0, 0
4000d9f0: 02 bf ff f4 be 4000d9c0 <fifo_open+0x1d8>
<== ALWAYS TAKEN
4000d9f4: 90 10 00 1b mov %i3, %o0
err = -EINTR;
4000d9f8: b0 10 3f fc mov -4, %i0
<== NOT EXECUTED
out_error:
pipe_release(pipep, iop);
4000d9fc: 92 10 00 19 mov %i1, %o1
<== NOT EXECUTED
4000da00: 7f ff ff 3a call 4000d6e8 <pipe_release>
4000da04: 90 10 00 1c mov %i4, %o0
return err;
4000da08: 81 c7 e0 08 ret
4000da0c: 81 e8 00 00 restore
c = 'a';
4000da10: 82 10 20 61 mov 0x61, %g1
4000da14: 10 bf ff 7d b 4000d808 <fifo_open+0x20>
4000da18: c2 2e a0 1c stb %g1, [ %i2 + 0x1c ]
pipe->readerCounter ++;
4000da1c: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000da20: 82 00 60 01 inc %g1
if (pipe->Readers ++ == 0)
4000da24: 86 00 a0 01 add %g2, 1, %g3
pipe->readerCounter ++;
4000da28: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
4000da2c: 80 a0 a0 00 cmp %g2, 0
4000da30: 02 80 00 3a be 4000db18 <fifo_open+0x330>
<== ALWAYS TAKEN
4000da34: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
if (pipe->Writers == 0) {
4000da38: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
4000da3c: 80 a0 60 00 cmp %g1, 0
4000da40: 12 bf ff 86 bne 4000d858 <fifo_open+0x70>
4000da44: b0 10 20 00 clr %i0
4000da48: c2 06 60 08 ld [ %i1 + 8 ], %g1
if (LIBIO_NODELAY(iop))
4000da4c: 80 88 60 01 btst 1, %g1
4000da50: 12 bf ff 82 bne 4000d858 <fifo_open+0x70>
4000da54: b0 10 20 00 clr %i0
prevCounter = pipe->writerCounter;
4000da58: 10 80 00 08 b 4000da78 <fifo_open+0x290>
4000da5c: f4 07 60 24 ld [ %i5 + 0x24 ], %i2
_Mutex_Acquire( mutex );
4000da60: 7f ff ed 7c call 40009050 <_Mutex_Acquire>
4000da64: 01 00 00 00 nop
} while (prevCounter == pipe->writerCounter);
4000da68: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000da6c: 80 a0 40 1a cmp %g1, %i2
4000da70: 12 bf ff 7a bne 4000d858 <fifo_open+0x70>
<== ALWAYS TAKEN
4000da74: b0 10 20 00 clr %i0
_Mutex_Release( mutex );
4000da78: 7f ff ed 92 call 400090c0 <_Mutex_Release>
4000da7c: 90 10 00 1b mov %i3, %o0
if (! PIPE_READWAIT(pipe))
4000da80: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
4000da84: 40 00 03 de call 4000e9fc <rtems_barrier_wait>
4000da88: 92 10 20 00 clr %o1
4000da8c: 80 a2 20 00 cmp %o0, 0
4000da90: 02 bf ff f4 be 4000da60 <fifo_open+0x278>
<== ALWAYS TAKEN
4000da94: 90 10 00 1b mov %i3, %o0
out_error:
4000da98: 10 bf ff d9 b 4000d9fc <fifo_open+0x214>
<== NOT EXECUTED
4000da9c: b0 10 3f fc mov -4, %i0
<== NOT EXECUTED
if (pipe->Readers ++ == 0)
4000daa0: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
pipe->readerCounter ++;
4000daa4: c2 07 60 20 ld [ %i5 + 0x20 ], %g1
4000daa8: 82 00 60 01 inc %g1
if (pipe->Readers ++ == 0)
4000daac: 86 00 a0 01 add %g2, 1, %g3
pipe->readerCounter ++;
4000dab0: c2 27 60 20 st %g1, [ %i5 + 0x20 ]
if (pipe->Readers ++ == 0)
4000dab4: 80 a0 a0 00 cmp %g2, 0
4000dab8: 02 80 00 1d be 4000db2c <fifo_open+0x344>
<== ALWAYS TAKEN
4000dabc: c6 27 60 10 st %g3, [ %i5 + 0x10 ]
if (pipe->Writers ++ == 0)
4000dac0: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
<== NOT EXECUTED
pipe->writerCounter ++;
4000dac4: c2 07 60 24 ld [ %i5 + 0x24 ], %g1
4000dac8: 82 00 60 01 inc %g1
if (pipe->Writers ++ == 0)
4000dacc: 86 00 a0 01 add %g2, 1, %g3
pipe->writerCounter ++;
4000dad0: c2 27 60 24 st %g1, [ %i5 + 0x24 ]
if (pipe->Writers ++ == 0)
4000dad4: 80 a0 a0 00 cmp %g2, 0
4000dad8: 12 bf ff 5f bne 4000d854 <fifo_open+0x6c>
<== NEVER TAKEN
4000dadc: c6 27 60 14 st %g3, [ %i5 + 0x14 ]
PIPE_WAKEUPREADERS(pipe);
4000dae0: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
4000dae4: 40 00 03 b1 call 4000e9a8 <rtems_barrier_release>
4000dae8: 92 07 bf fc add %fp, -4, %o1
return 0;
4000daec: 10 bf ff 5b b 4000d858 <fifo_open+0x70>
4000daf0: b0 10 20 00 clr %i0
4000daf4: 7f ff ed 73 call 400090c0 <_Mutex_Release>
4000daf8: b0 10 3f fa mov -6, %i0
goto out_error;
4000dafc: 10 bf ff c1 b 4000da00 <fifo_open+0x218>
4000db00: 92 10 00 19 mov %i1, %o1
PIPE_WAKEUPREADERS(pipe);
4000db04: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
4000db08: 40 00 03 a8 call 4000e9a8 <rtems_barrier_release>
4000db0c: 92 07 bf fc add %fp, -4, %o1
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
4000db10: 10 bf ff 9f b 4000d98c <fifo_open+0x1a4>
4000db14: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
PIPE_WAKEUPWRITERS(pipe);
4000db18: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
4000db1c: 40 00 03 a3 call 4000e9a8 <rtems_barrier_release>
4000db20: 92 07 bf fc add %fp, -4, %o1
if (pipe->Writers == 0) {
4000db24: 10 bf ff c6 b 4000da3c <fifo_open+0x254>
4000db28: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
PIPE_WAKEUPWRITERS(pipe);
4000db2c: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
4000db30: 40 00 03 9e call 4000e9a8 <rtems_barrier_release>
4000db34: 92 07 bf fc add %fp, -4, %o1
if (pipe->Writers ++ == 0)
4000db38: 10 bf ff e3 b 4000dac4 <fifo_open+0x2dc>
4000db3c: c4 07 60 14 ld [ %i5 + 0x14 ], %g2
rtems_barrier_delete(pipe->readBarrier);
4000db40: 40 00 03 6f call 4000e8fc <rtems_barrier_delete>
4000db44: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
free(pipe->Buffer);
4000db48: 7f ff dd 30 call 40005008 <free>
4000db4c: d0 07 40 00 ld [ %i5 ], %o0
free(pipe);
4000db50: 7f ff dd 2e call 40005008 <free>
4000db54: 90 10 00 1d mov %i5, %o0
return err;
4000db58: b0 10 3f f4 mov -12, %i0
4000db5c: 7f ff ed 59 call 400090c0 <_Mutex_Release>
4000db60: 90 16 e0 20 or %i3, 0x20, %o0
4000db64: 81 c7 e0 08 ret
4000db68: 81 e8 00 00 restore
return err;
4000db6c: b0 10 3f f4 mov -12, %i0
<== NOT EXECUTED
4000db70: 7f ff ed 54 call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000db74: 90 16 e0 20 or %i3, 0x20, %o0
<== NOT EXECUTED
}
4000db78: 81 c7 e0 08 ret
<== NOT EXECUTED
4000db7c: 81 e8 00 00 restore
<== NOT EXECUTED
4000c568 <pipe_create>:
static uint16_t rtems_pipe_no = 0;
int pipe_create(
int filsdes[2]
)
{
4000c568: 9d e3 bf 90 save %sp, -112, %sp
rtems_libio_t *iop;
int err = 0;
if (rtems_mkdir("/tmp", S_IRWXU | S_IRWXG | S_IRWXO) != 0)
4000c56c: 92 10 21 ff mov 0x1ff, %o1
4000c570: 11 10 00 63 sethi %hi(0x40018c00), %o0
4000c574: 40 00 06 ec call 4000e124 <rtems_mkdir>
4000c578: 90 12 21 a8 or %o0, 0x1a8, %o0 ! 40018da8 <_Thread_queue_Operations_default+0x14>
4000c57c: 80 a2 20 00 cmp %o0, 0
4000c580: 12 80 00 48 bne 4000c6a0 <pipe_create+0x138>
4000c584: 03 10 00 6f sethi %hi(0x4001bc00), %g1
return -1;
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000c588: d4 10 60 10 lduh [ %g1 + 0x10 ], %o2 ! 4001bc10 <rtems_pipe_no>
4000c58c: 84 02 a0 01 add %o2, 1, %g2
4000c590: c4 30 60 10 sth %g2, [ %g1 + 0x10 ]
memcpy(fifopath, "/tmp/.fifo", 10);
4000c594: 03 00 00 19 sethi %hi(0x6400), %g1
4000c598: 82 10 62 6f or %g1, 0x26f, %g1 ! 666f <_Configuration_Interrupt_stack_size+0x566f>
4000c59c: 39 0b dd 1b sethi %hi(0x2f746c00), %i4
4000c5a0: c2 37 bf f8 sth %g1, [ %fp + -8 ]
4000c5a4: b8 17 21 70 or %i4, 0x170, %i4
4000c5a8: 3b 0b cb 99 sethi %hi(0x2f2e6400), %i5
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000c5ac: 13 10 00 63 sethi %hi(0x40018c00), %o1
memcpy(fifopath, "/tmp/.fifo", 10);
4000c5b0: ba 17 62 69 or %i5, 0x269, %i5
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000c5b4: 92 12 61 b0 or %o1, 0x1b0, %o1
memcpy(fifopath, "/tmp/.fifo", 10);
4000c5b8: f8 3f bf f0 std %i4, [ %fp + -16 ]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
4000c5bc: 40 00 10 f7 call 40010998 <sprintf>
4000c5c0: 90 07 bf fa add %fp, -6, %o0
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
4000c5c4: 92 10 21 80 mov 0x180, %o1
4000c5c8: 40 00 06 5f call 4000df44 <mkfifo>
4000c5cc: 90 07 bf f0 add %fp, -16, %o0
4000c5d0: ba 92 20 00 orcc %o0, 0, %i5
4000c5d4: 12 80 00 35 bne 4000c6a8 <pipe_create+0x140>
<== NEVER TAKEN
4000c5d8: 13 00 00 10 sethi %hi(0x4000), %o1
return -1;
/* sprintf(fifopath + 10, "%04x", rtems_pipe_no ++); */
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
4000c5dc: 7f ff e3 77 call 400053b8 <open>
4000c5e0: 90 07 bf f0 add %fp, -16, %o0
if (filsdes[0] < 0) {
4000c5e4: 80 a2 20 00 cmp %o0, 0
4000c5e8: 06 80 00 18 bl 4000c648 <pipe_create+0xe0>
4000c5ec: d0 26 00 00 st %o0, [ %i0 ]
return &rtems_libio_iops[ fd ];
4000c5f0: 83 2a 20 01 sll %o0, 1, %g1
<== NOT EXECUTED
4000c5f4: 90 00 40 08 add %g1, %o0, %o0
<== NOT EXECUTED
4000c5f8: 03 10 00 6f sethi %hi(0x4001bc00), %g1
<== NOT EXECUTED
4000c5fc: 91 2a 20 04 sll %o0, 4, %o0
<== NOT EXECUTED
4000c600: 82 10 61 d0 or %g1, 0x1d0, %g1
<== NOT EXECUTED
4000c604: 90 02 00 01 add %o0, %g1, %o0
<== NOT EXECUTED
__asm__ volatile ( "ta %1\n\t" : "=r" (psr) : "i" (SPARC_SWTRAP_IRQDIS));
4000c608: 91 d0 20 09 ta 9
<== NOT EXECUTED
*obj = val & arg;
4000c60c: c4 02 20 08 ld [ %o0 + 8 ], %g2
<== NOT EXECUTED
4000c610: 84 08 bf fe and %g2, -2, %g2
<== NOT EXECUTED
4000c614: c4 22 20 08 st %g2, [ %o0 + 8 ]
<== NOT EXECUTED
__asm__ volatile ( "ta %0\nnop\n" :: "i" (SPARC_SWTRAP_IRQEN), "r" (_psr));
4000c618: 91 d0 20 0a ta 0xa
<== NOT EXECUTED
4000c61c: 01 00 00 00 nop
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
rtems_libio_iop_flags_clear( iop, LIBIO_FLAGS_NO_DELAY );
filsdes[1] = open(fifopath, O_WRONLY);
4000c620: 92 10 20 01 mov 1, %o1 ! 1 <_TLS_Alignment>
4000c624: 7f ff e3 65 call 400053b8 <open>
4000c628: 90 07 bf f0 add %fp, -16, %o0
if (filsdes[1] < 0) {
4000c62c: 80 a2 20 00 cmp %o0, 0
4000c630: 06 80 00 13 bl 4000c67c <pipe_create+0x114>
4000c634: d0 26 20 04 st %o0, [ %i0 + 4 ]
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
4000c638: 7f ff e8 11 call 4000667c <unlink>
4000c63c: 90 07 bf f0 add %fp, -16, %o0
}
if(err != 0)
rtems_set_errno_and_return_minus_one(err);
return 0;
}
4000c640: 81 c7 e0 08 ret
4000c644: 91 e8 00 1d restore %g0, %i5, %o0
err = errno;
4000c648: 40 00 0f b8 call 40010528 <__errno>
4000c64c: 01 00 00 00 nop
4000c650: fa 02 00 00 ld [ %o0 ], %i5
unlink(fifopath);
4000c654: 7f ff e8 0a call 4000667c <unlink>
4000c658: 90 07 bf f0 add %fp, -16, %o0
if(err != 0)
4000c65c: 80 a7 60 00 cmp %i5, 0
4000c660: 02 bf ff f8 be 4000c640 <pipe_create+0xd8>
<== NEVER TAKEN
4000c664: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one(err);
4000c668: 40 00 0f b0 call 40010528 <__errno>
4000c66c: 01 00 00 00 nop
4000c670: fa 22 00 00 st %i5, [ %o0 ]
4000c674: 10 bf ff f3 b 4000c640 <pipe_create+0xd8>
4000c678: ba 10 3f ff mov -1, %i5
err = errno;
4000c67c: 40 00 0f ab call 40010528 <__errno>
4000c680: 01 00 00 00 nop
4000c684: fa 02 00 00 ld [ %o0 ], %i5
close(filsdes[0]);
4000c688: 7f ff e0 4b call 400047b4 <close>
4000c68c: d0 06 00 00 ld [ %i0 ], %o0
unlink(fifopath);
4000c690: 7f ff e7 fb call 4000667c <unlink>
4000c694: 90 07 bf f0 add %fp, -16, %o0
if(err != 0)
4000c698: 10 bf ff f2 b 4000c660 <pipe_create+0xf8>
4000c69c: 80 a7 60 00 cmp %i5, 0
return -1;
4000c6a0: 10 bf ff e8 b 4000c640 <pipe_create+0xd8>
4000c6a4: ba 10 3f ff mov -1, %i5
if (errno != EEXIST){
4000c6a8: 40 00 0f a0 call 40010528 <__errno>
<== NOT EXECUTED
4000c6ac: ba 10 3f ff mov -1, %i5
<== NOT EXECUTED
4000c6b0: 30 bf ff e4 b,a 4000c640 <pipe_create+0xd8>
<== NOT EXECUTED
4000c6b4: 00 00 00 00 unimp 0
<== NOT EXECUTED
...
4000df30 <pipe_ioctl>:
pipe_control_t *pipe,
ioctl_command_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
4000df30: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if (cmd == FIONREAD) {
4000df34: 03 10 01 19 sethi %hi(0x40046400), %g1
<== NOT EXECUTED
4000df38: 82 10 62 7f or %g1, 0x27f, %g1 ! 4004667f <__end+0x2915f>
<== NOT EXECUTED
4000df3c: 80 a6 40 01 cmp %i1, %g1
<== NOT EXECUTED
4000df40: 12 80 00 0d bne 4000df74 <pipe_ioctl+0x44>
<== NOT EXECUTED
4000df44: 80 a6 a0 00 cmp %i2, 0
if (buffer == NULL)
4000df48: 02 80 00 0d be 4000df7c <pipe_ioctl+0x4c>
4000df4c: ba 06 20 28 add %i0, 0x28, %i5
_Mutex_Acquire( mutex );
4000df50: 7f ff ec 40 call 40009050 <_Mutex_Acquire>
4000df54: 90 10 00 1d mov %i5, %o0
return -EFAULT;
PIPE_LOCK(pipe);
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
4000df58: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000df5c: c2 26 80 00 st %g1, [ %i2 ]
_Mutex_Release( mutex );
4000df60: 90 10 00 1d mov %i5, %o0
4000df64: 7f ff ec 57 call 400090c0 <_Mutex_Release>
4000df68: b0 10 20 00 clr %i0
PIPE_UNLOCK(pipe);
return 0;
4000df6c: 81 c7 e0 08 ret
4000df70: 81 e8 00 00 restore
}
return -EINVAL;
4000df74: 81 c7 e0 08 ret
4000df78: 91 e8 3f ea restore %g0, -22, %o0
}
4000df7c: 81 c7 e0 08 ret
4000df80: 91 e8 3f f2 restore %g0, -14, %o0
4000db80 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4000db80: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
PIPE_LOCK(pipe);
4000db84: b8 06 20 28 add %i0, 0x28, %i4
<== NOT EXECUTED
_Mutex_Acquire( mutex );
4000db88: 7f ff ed 32 call 40009050 <_Mutex_Acquire>
<== NOT EXECUTED
4000db8c: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
while (PIPE_EMPTY(pipe)) {
4000db90: c2 06 20 0c ld [ %i0 + 0xc ], %g1
4000db94: 80 a0 60 00 cmp %g1, 0
4000db98: 12 80 00 27 bne 4000dc34 <pipe_read+0xb4>
4000db9c: ba 10 00 18 mov %i0, %i5
/* Not an error */
if (pipe->Writers == 0)
4000dba0: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000dba4: 80 a0 60 00 cmp %g1, 0
4000dba8: 22 80 00 16 be,a 4000dc00 <pipe_read+0x80>
4000dbac: b0 10 20 00 clr %i0
4000dbb0: c2 06 e0 08 ld [ %i3 + 8 ], %g1
goto out_locked;
if (LIBIO_NODELAY(iop)) {
4000dbb4: 80 88 60 01 btst 1, %g1
4000dbb8: 32 80 00 12 bne,a 4000dc00 <pipe_read+0x80>
4000dbbc: b0 10 3f f5 mov -11, %i0
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
4000dbc0: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000dbc4: 82 00 60 01 inc %g1
4000dbc8: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
_Mutex_Release( mutex );
4000dbcc: 7f ff ed 3d call 400090c0 <_Mutex_Release>
4000dbd0: 90 10 00 1c mov %i4, %o0
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
4000dbd4: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
4000dbd8: 40 00 03 89 call 4000e9fc <rtems_barrier_wait>
4000dbdc: 92 10 20 00 clr %o1
4000dbe0: 80 a2 20 00 cmp %o0, 0
4000dbe4: 02 80 00 0b be 4000dc10 <pipe_read+0x90>
<== ALWAYS TAKEN
4000dbe8: 90 10 00 1c mov %i4, %o0
_Mutex_Acquire( mutex );
4000dbec: 7f ff ed 19 call 40009050 <_Mutex_Acquire>
<== NOT EXECUTED
4000dbf0: b0 10 3f fc mov -4, %i0
<== NOT EXECUTED
ret = -EINTR;
PIPE_LOCK(pipe);
pipe->waitingReaders --;
4000dbf4: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
<== NOT EXECUTED
4000dbf8: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4000dbfc: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
<== NOT EXECUTED
_Mutex_Release( mutex );
4000dc00: 7f ff ed 30 call 400090c0 <_Mutex_Release>
4000dc04: 90 10 00 1c mov %i4, %o0
PIPE_UNLOCK(pipe);
if (read > 0)
return read;
return ret;
}
4000dc08: 81 c7 e0 08 ret
4000dc0c: 81 e8 00 00 restore
_Mutex_Acquire( mutex );
4000dc10: 7f ff ed 10 call 40009050 <_Mutex_Acquire>
4000dc14: 01 00 00 00 nop
pipe->waitingReaders --;
4000dc18: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000dc1c: 82 00 7f ff add %g1, -1, %g1
4000dc20: c2 27 60 18 st %g1, [ %i5 + 0x18 ]
while (PIPE_EMPTY(pipe)) {
4000dc24: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000dc28: 80 a0 60 00 cmp %g1, 0
4000dc2c: 22 bf ff de be,a 4000dba4 <pipe_read+0x24>
<== NEVER TAKEN
4000dc30: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
<== NOT EXECUTED
chunk = MIN(count - read, pipe->Length);
4000dc34: 80 a6 80 01 cmp %i2, %g1
4000dc38: 38 80 00 33 bgu,a 4000dd04 <pipe_read+0x184>
<== NEVER TAKEN
4000dc3c: b4 10 00 01 mov %g1, %i2
<== NOT EXECUTED
chunk1 = pipe->Size - pipe->Start;
4000dc40: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000dc44: f6 07 60 04 ld [ %i5 + 4 ], %i3
4000dc48: d2 07 40 00 ld [ %i5 ], %o1
4000dc4c: b6 26 c0 01 sub %i3, %g1, %i3
if (chunk > chunk1) {
4000dc50: 80 a6 80 1b cmp %i2, %i3
4000dc54: 14 80 00 23 bg 4000dce0 <pipe_read+0x160>
4000dc58: 92 02 40 01 add %o1, %g1, %o1
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
4000dc5c: 94 10 00 1a mov %i2, %o2
4000dc60: 40 00 0b ae call 40010b18 <memcpy>
4000dc64: 90 10 00 19 mov %i1, %o0
pipe->Start += chunk;
4000dc68: c2 07 60 08 ld [ %i5 + 8 ], %g1
pipe->Length -= chunk;
4000dc6c: c4 07 60 0c ld [ %i5 + 0xc ], %g2
pipe->Start %= pipe->Size;
4000dc70: c8 07 60 04 ld [ %i5 + 4 ], %g4
pipe->Start += chunk;
4000dc74: 82 06 80 01 add %i2, %g1, %g1
pipe->Length -= chunk;
4000dc78: 84 20 80 1a sub %g2, %i2, %g2
pipe->Start %= pipe->Size;
4000dc7c: 81 80 20 00 wr %g0, %y
4000dc80: 01 00 00 00 nop
4000dc84: 01 00 00 00 nop
4000dc88: 01 00 00 00 nop
4000dc8c: 86 70 40 04 udiv %g1, %g4, %g3
pipe->Length -= chunk;
4000dc90: c4 27 60 0c st %g2, [ %i5 + 0xc ]
pipe->Start %= pipe->Size;
4000dc94: 86 58 c0 04 smul %g3, %g4, %g3
4000dc98: 82 20 40 03 sub %g1, %g3, %g1
if (PIPE_EMPTY(pipe))
4000dc9c: 80 a0 a0 00 cmp %g2, 0
4000dca0: 12 80 00 03 bne 4000dcac <pipe_read+0x12c>
4000dca4: c2 27 60 08 st %g1, [ %i5 + 8 ]
pipe->Start = 0;
4000dca8: c0 27 60 08 clr [ %i5 + 8 ]
if (pipe->waitingWriters > 0)
4000dcac: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000dcb0: 80 a0 60 00 cmp %g1, 0
4000dcb4: 32 80 00 1d bne,a 4000dd28 <pipe_read+0x1a8>
4000dcb8: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
_Mutex_Release( mutex );
4000dcbc: 7f ff ed 01 call 400090c0 <_Mutex_Release>
4000dcc0: 90 10 00 1c mov %i4, %o0
4000dcc4: b0 96 a0 00 orcc %i2, 0, %i0
4000dcc8: 16 bf ff d0 bge 4000dc08 <pipe_read+0x88>
<== ALWAYS TAKEN
4000dccc: 01 00 00 00 nop
4000dcd0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000dcd4: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
ret = -EAGAIN;
4000dcd8: 10 bf ff ca b 4000dc00 <pipe_read+0x80>
<== NOT EXECUTED
4000dcdc: b0 10 3f f5 mov -11, %i0
<== NOT EXECUTED
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
4000dce0: 94 10 00 1b mov %i3, %o2
4000dce4: 40 00 0b 8d call 40010b18 <memcpy>
4000dce8: 90 10 00 19 mov %i1, %o0
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
4000dcec: d2 07 40 00 ld [ %i5 ], %o1
4000dcf0: 94 26 80 1b sub %i2, %i3, %o2
4000dcf4: 40 00 0b 89 call 40010b18 <memcpy>
4000dcf8: 90 06 40 1b add %i1, %i3, %o0
4000dcfc: 10 bf ff dc b 4000dc6c <pipe_read+0xec>
4000dd00: c2 07 60 08 ld [ %i5 + 8 ], %g1
chunk1 = pipe->Size - pipe->Start;
4000dd04: f6 07 60 04 ld [ %i5 + 4 ], %i3
<== NOT EXECUTED
4000dd08: c2 07 60 08 ld [ %i5 + 8 ], %g1
<== NOT EXECUTED
4000dd0c: d2 07 40 00 ld [ %i5 ], %o1
<== NOT EXECUTED
4000dd10: b6 26 c0 01 sub %i3, %g1, %i3
<== NOT EXECUTED
if (chunk > chunk1) {
4000dd14: 80 a6 80 1b cmp %i2, %i3
<== NOT EXECUTED
4000dd18: 04 bf ff d1 ble 4000dc5c <pipe_read+0xdc>
<== NOT EXECUTED
4000dd1c: 92 02 40 01 add %o1, %g1, %o1
<== NOT EXECUTED
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
4000dd20: 10 bf ff f1 b 4000dce4 <pipe_read+0x164>
<== NOT EXECUTED
4000dd24: 94 10 00 1b mov %i3, %o2
<== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
4000dd28: 40 00 03 20 call 4000e9a8 <rtems_barrier_release>
4000dd2c: 92 07 bf fc add %fp, -4, %o1
4000dd30: 30 bf ff e3 b,a 4000dcbc <pipe_read+0x13c>
4000d6e8 <pipe_release>:
void pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
4000d6e8: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
mutex->_Queue._name = name;
}
static __inline void rtems_mutex_lock( rtems_mutex *mutex )
{
_Mutex_Acquire( mutex );
4000d6ec: 39 10 00 6d sethi %hi(0x4001b400), %i4
<== NOT EXECUTED
pipe_control_t *pipe = *pipep;
4000d6f0: fa 06 00 00 ld [ %i0 ], %i5
<== NOT EXECUTED
4000d6f4: 7f ff ee 57 call 40009050 <_Mutex_Acquire>
<== NOT EXECUTED
4000d6f8: 90 17 20 20 or %i4, 0x20, %o0
<== NOT EXECUTED
uint32_t mode;
pipe_lock();
PIPE_LOCK(pipe);
4000d6fc: b6 07 60 28 add %i5, 0x28, %i3
4000d700: 7f ff ee 54 call 40009050 <_Mutex_Acquire>
4000d704: 90 10 00 1b mov %i3, %o0
4000d708: c2 06 60 08 ld [ %i1 + 8 ], %g1
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
4000d70c: 80 88 60 02 btst 2, %g1
4000d710: 02 80 00 05 be 4000d724 <pipe_release+0x3c>
4000d714: b4 08 60 06 and %g1, 6, %i2
pipe->Readers --;
4000d718: c4 07 60 10 ld [ %i5 + 0x10 ], %g2
4000d71c: 84 00 bf ff add %g2, -1, %g2
4000d720: c4 27 60 10 st %g2, [ %i5 + 0x10 ]
if (mode & LIBIO_FLAGS_WRITE)
4000d724: 80 88 60 04 btst 4, %g1
4000d728: 02 80 00 05 be 4000d73c <pipe_release+0x54>
4000d72c: 01 00 00 00 nop
pipe->Writers --;
4000d730: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
4000d734: 82 00 7f ff add %g1, -1, %g1
4000d738: c2 27 60 14 st %g1, [ %i5 + 0x14 ]
}
static __inline void rtems_mutex_unlock( rtems_mutex *mutex )
{
_Mutex_Release( mutex );
4000d73c: 7f ff ee 61 call 400090c0 <_Mutex_Release>
4000d740: 90 10 00 1b mov %i3, %o0
PIPE_UNLOCK(pipe);
if (pipe->Readers == 0 && pipe->Writers == 0) {
4000d744: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000d748: 80 a0 60 00 cmp %g1, 0
4000d74c: 02 80 00 0e be 4000d784 <pipe_release+0x9c>
4000d750: c2 07 60 14 ld [ %i5 + 0x14 ], %g1
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
4000d754: 80 a0 60 00 cmp %g1, 0
4000d758: 12 80 00 07 bne 4000d774 <pipe_release+0x8c>
<== NEVER TAKEN
4000d75c: 80 a6 a0 02 cmp %i2, 2
4000d760: 02 80 00 05 be 4000d774 <pipe_release+0x8c>
<== NEVER TAKEN
4000d764: 01 00 00 00 nop
PIPE_WAKEUPREADERS(pipe);
4000d768: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
4000d76c: 40 00 04 8f call 4000e9a8 <rtems_barrier_release>
4000d770: 92 07 bf fc add %fp, -4, %o1
4000d774: 7f ff ee 53 call 400090c0 <_Mutex_Release>
4000d778: 90 17 20 20 or %i4, 0x20, %o0
rtems_libio_iop_flags_clear( iop, LIBIO_FLAGS_OPEN );
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return;
#endif
}
4000d77c: 81 c7 e0 08 ret
4000d780: 81 e8 00 00 restore
if (pipe->Readers == 0 && pipe->Writers == 0) {
4000d784: 80 a0 60 00 cmp %g1, 0
4000d788: 02 80 00 0b be 4000d7b4 <pipe_release+0xcc>
4000d78c: 80 a6 a0 04 cmp %i2, 4
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
4000d790: 02 bf ff f9 be 4000d774 <pipe_release+0x8c>
<== NEVER TAKEN
4000d794: 01 00 00 00 nop
PIPE_WAKEUPWRITERS(pipe);
4000d798: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
4000d79c: 40 00 04 83 call 4000e9a8 <rtems_barrier_release>
4000d7a0: 92 07 bf fc add %fp, -4, %o1
4000d7a4: 7f ff ee 47 call 400090c0 <_Mutex_Release>
4000d7a8: 90 17 20 20 or %i4, 0x20, %o0
}
4000d7ac: 81 c7 e0 08 ret
4000d7b0: 81 e8 00 00 restore
rtems_barrier_delete(pipe->readBarrier);
4000d7b4: 40 00 04 52 call 4000e8fc <rtems_barrier_delete>
4000d7b8: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
rtems_barrier_delete(pipe->writeBarrier);
4000d7bc: 40 00 04 50 call 4000e8fc <rtems_barrier_delete>
4000d7c0: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
free(pipe->Buffer);
4000d7c4: 7f ff de 11 call 40005008 <free>
4000d7c8: d0 07 40 00 ld [ %i5 ], %o0
free(pipe);
4000d7cc: 7f ff de 0f call 40005008 <free>
4000d7d0: 90 10 00 1d mov %i5, %o0
*pipep = NULL;
4000d7d4: c0 26 00 00 clr [ %i0 ]
4000d7d8: 7f ff ee 3a call 400090c0 <_Mutex_Release>
4000d7dc: 90 17 20 20 or %i4, 0x20, %o0
}
4000d7e0: 81 c7 e0 08 ret
4000d7e4: 81 e8 00 00 restore
4000dd34 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
4000dd34: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
4000dd38: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
4000dd3c: 80 a6 a0 00 cmp %i2, 0
<== NOT EXECUTED
4000dd40: 02 80 00 36 be 4000de18 <pipe_write+0xe4>
<== NOT EXECUTED
4000dd44: b0 10 20 00 clr %i0
return 0;
PIPE_LOCK(pipe);
4000dd48: b8 07 60 28 add %i5, 0x28, %i4
_Mutex_Acquire( mutex );
4000dd4c: 7f ff ec c1 call 40009050 <_Mutex_Acquire>
4000dd50: 90 10 00 1c mov %i4, %o0
if (pipe->Readers == 0) {
4000dd54: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000dd58: 80 a0 60 00 cmp %g1, 0
4000dd5c: 02 80 00 29 be 4000de00 <pipe_write+0xcc>
4000dd60: 01 00 00 00 nop
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
4000dd64: c2 07 60 04 ld [ %i5 + 4 ], %g1
4000dd68: 80 a0 40 1a cmp %g1, %i2
4000dd6c: 1a 80 00 03 bcc 4000dd78 <pipe_write+0x44>
<== ALWAYS TAKEN
4000dd70: a0 10 00 1a mov %i2, %l0
4000dd74: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
4000dd78: b0 10 20 00 clr %i0
4000dd7c: a2 10 20 00 clr %l1
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
4000dd80: c4 07 60 0c ld [ %i5 + 0xc ], %g2
4000dd84: 86 20 40 02 sub %g1, %g2, %g3
4000dd88: 80 a0 c0 10 cmp %g3, %l0
4000dd8c: 1a 80 00 30 bcc 4000de4c <pipe_write+0x118>
4000dd90: a4 26 80 11 sub %i2, %l1, %l2
4000dd94: c2 06 e0 08 ld [ %i3 + 8 ], %g1
if (LIBIO_NODELAY(iop)) {
4000dd98: 80 88 60 01 btst 1, %g1
4000dd9c: 32 80 00 12 bne,a 4000dde4 <pipe_write+0xb0>
4000dda0: b6 10 3f f5 mov -11, %i3
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
4000dda4: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000dda8: 82 00 60 01 inc %g1
4000ddac: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
_Mutex_Release( mutex );
4000ddb0: 7f ff ec c4 call 400090c0 <_Mutex_Release>
4000ddb4: 90 10 00 1c mov %i4, %o0
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
4000ddb8: d0 07 60 40 ld [ %i5 + 0x40 ], %o0
4000ddbc: 40 00 03 10 call 4000e9fc <rtems_barrier_wait>
4000ddc0: 92 10 20 00 clr %o1
4000ddc4: 80 a2 20 00 cmp %o0, 0
4000ddc8: 02 80 00 16 be 4000de20 <pipe_write+0xec>
<== ALWAYS TAKEN
4000ddcc: 90 10 00 1c mov %i4, %o0
_Mutex_Acquire( mutex );
4000ddd0: 7f ff ec a0 call 40009050 <_Mutex_Acquire>
<== NOT EXECUTED
4000ddd4: b6 10 3f fc mov -4, %i3
<== NOT EXECUTED
ret = -EINTR;
PIPE_LOCK(pipe);
pipe->waitingWriters --;
4000ddd8: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
<== NOT EXECUTED
4000dddc: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
4000dde0: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
<== NOT EXECUTED
_Mutex_Release( mutex );
4000dde4: 7f ff ec b7 call 400090c0 <_Mutex_Release>
4000dde8: 90 10 00 1c mov %i4, %o0
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
4000ddec: 80 a6 20 00 cmp %i0, 0
4000ddf0: 14 80 00 0a bg 4000de18 <pipe_write+0xe4>
4000ddf4: 01 00 00 00 nop
4000ddf8: 81 c7 e0 08 ret
4000ddfc: 91 e8 00 1b restore %g0, %i3, %o0
4000de00: 7f ff ec b0 call 400090c0 <_Mutex_Release>
4000de04: 90 10 00 1c mov %i4, %o0
kill(getpid(), SIGPIPE);
4000de08: 40 00 01 7d call 4000e3fc <getpid>
4000de0c: b0 10 3f e0 mov -32, %i0
4000de10: 40 00 02 8b call 4000e83c <kill>
4000de14: 92 10 20 0d mov 0xd, %o1
4000de18: 81 c7 e0 08 ret
4000de1c: 81 e8 00 00 restore
_Mutex_Acquire( mutex );
4000de20: 7f ff ec 8c call 40009050 <_Mutex_Acquire>
4000de24: 01 00 00 00 nop
pipe->waitingWriters --;
4000de28: c2 07 60 1c ld [ %i5 + 0x1c ], %g1
4000de2c: 82 00 7f ff add %g1, -1, %g1
4000de30: c2 27 60 1c st %g1, [ %i5 + 0x1c ]
if (pipe->Readers == 0) {
4000de34: c2 07 60 10 ld [ %i5 + 0x10 ], %g1
4000de38: 80 a0 60 00 cmp %g1, 0
4000de3c: 02 80 00 26 be 4000ded4 <pipe_write+0x1a0>
<== NEVER TAKEN
4000de40: 01 00 00 00 nop
4000de44: 10 bf ff cf b 4000dd80 <pipe_write+0x4c>
4000de48: c2 07 60 04 ld [ %i5 + 4 ], %g1
chunk = MIN(count - written, PIPE_SPACE(pipe));
4000de4c: 80 a4 80 03 cmp %l2, %g3
4000de50: 38 80 00 02 bgu,a 4000de58 <pipe_write+0x124>
<== NEVER TAKEN
4000de54: a4 10 00 03 mov %g3, %l2
<== NOT EXECUTED
chunk1 = pipe->Size - PIPE_WSTART(pipe);
4000de58: c8 07 60 08 ld [ %i5 + 8 ], %g4
4000de5c: 84 00 80 04 add %g2, %g4, %g2
4000de60: c6 07 40 00 ld [ %i5 ], %g3
4000de64: 81 80 20 00 wr %g0, %y
4000de68: 01 00 00 00 nop
4000de6c: 01 00 00 00 nop
4000de70: 01 00 00 00 nop
4000de74: 90 70 80 01 udiv %g2, %g1, %o0
4000de78: 90 5a 00 01 smul %o0, %g1, %o0
4000de7c: 92 06 40 11 add %i1, %l1, %o1
4000de80: 84 20 80 08 sub %g2, %o0, %g2
4000de84: a0 20 40 02 sub %g1, %g2, %l0
if (chunk > chunk1) {
4000de88: 80 a4 80 10 cmp %l2, %l0
4000de8c: 14 80 00 1a bg 4000def4 <pipe_write+0x1c0>
4000de90: 90 00 c0 02 add %g3, %g2, %o0
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
4000de94: 40 00 0b 21 call 40010b18 <memcpy>
4000de98: 94 10 00 12 mov %l2, %o2
pipe->Length += chunk;
4000de9c: c2 07 60 0c ld [ %i5 + 0xc ], %g1
4000dea0: 82 00 40 12 add %g1, %l2, %g1
4000dea4: c2 27 60 0c st %g1, [ %i5 + 0xc ]
if (pipe->waitingReaders > 0)
4000dea8: c2 07 60 18 ld [ %i5 + 0x18 ], %g1
4000deac: 80 a0 60 00 cmp %g1, 0
4000deb0: 32 80 00 1a bne,a 4000df18 <pipe_write+0x1e4>
4000deb4: d0 07 60 3c ld [ %i5 + 0x3c ], %o0
written += chunk;
4000deb8: b0 06 00 12 add %i0, %l2, %i0
while (written < count) {
4000debc: 80 a6 00 1a cmp %i0, %i2
4000dec0: 1a 80 00 1a bcc 4000df28 <pipe_write+0x1f4>
<== ALWAYS TAKEN
4000dec4: a2 10 00 18 mov %i0, %l1
4000dec8: c2 07 60 04 ld [ %i5 + 4 ], %g1
<== NOT EXECUTED
chunk = 1;
4000decc: 10 bf ff ad b 4000dd80 <pipe_write+0x4c>
<== NOT EXECUTED
4000ded0: a0 10 20 01 mov 1, %l0
<== NOT EXECUTED
_Mutex_Release( mutex );
4000ded4: 7f ff ec 7b call 400090c0 <_Mutex_Release>
<== NOT EXECUTED
4000ded8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
kill(getpid(), SIGPIPE);
4000dedc: 40 00 01 48 call 4000e3fc <getpid>
<== NOT EXECUTED
4000dee0: b6 10 3f e0 mov -32, %i3
<== NOT EXECUTED
4000dee4: 40 00 02 56 call 4000e83c <kill>
<== NOT EXECUTED
4000dee8: 92 10 20 0d mov 0xd, %o1
<== NOT EXECUTED
if (written > 0)
4000deec: 10 bf ff c1 b 4000ddf0 <pipe_write+0xbc>
<== NOT EXECUTED
4000def0: 80 a6 20 00 cmp %i0, 0
<== NOT EXECUTED
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
4000def4: 40 00 0b 09 call 40010b18 <memcpy>
4000def8: 94 10 00 10 mov %l0, %o2
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
4000defc: d0 07 40 00 ld [ %i5 ], %o0
4000df00: 92 04 00 11 add %l0, %l1, %o1
4000df04: 94 24 80 10 sub %l2, %l0, %o2
4000df08: 40 00 0b 04 call 40010b18 <memcpy>
4000df0c: 92 06 40 09 add %i1, %o1, %o1
4000df10: 10 bf ff e4 b 4000dea0 <pipe_write+0x16c>
4000df14: c2 07 60 0c ld [ %i5 + 0xc ], %g1
PIPE_WAKEUPREADERS(pipe);
4000df18: 40 00 02 a4 call 4000e9a8 <rtems_barrier_release>
4000df1c: 92 07 bf fc add %fp, -4, %o1
written += chunk;
4000df20: 10 bf ff e7 b 4000debc <pipe_write+0x188>
4000df24: b0 06 00 12 add %i0, %l2, %i0
out_locked:
4000df28: 10 bf ff af b 4000dde4 <pipe_write+0xb0>
4000df2c: b6 10 20 00 clr %i3
40005670 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
40005670: 9d e3 bf 40 save %sp, -192, %sp
<== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
struct stat st;
int rv = stat( name, &st );
40005674: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
{
40005678: ba 10 00 18 mov %i0, %i5
<== NOT EXECUTED
int rv = stat( name, &st );
4000567c: 92 07 bf a0 add %fp, -96, %o1
<== NOT EXECUTED
40005680: 40 00 03 54 call 400063d0 <stat>
<== NOT EXECUTED
40005684: b0 10 20 0d mov 0xd, %i0
<== NOT EXECUTED
if ( rv == 0 && S_ISCHR( st.st_mode ) ) {
40005688: 80 a2 20 00 cmp %o0, 0
4000568c: 12 80 00 11 bne 400056d0 <rtems_io_lookup_name+0x60>
40005690: 05 00 00 3c sethi %hi(0xf000), %g2
40005694: c2 07 bf ac ld [ %fp + -84 ], %g1
40005698: 82 08 40 02 and %g1, %g2, %g1
4000569c: 05 00 00 08 sethi %hi(0x2000), %g2
400056a0: 80 a0 40 02 cmp %g1, %g2
400056a4: 12 80 00 0b bne 400056d0 <rtems_io_lookup_name+0x60>
400056a8: 01 00 00 00 nop
device_info->device_name = name;
400056ac: fa 26 40 00 st %i5, [ %i1 ]
device_info->device_name_length = strlen( name );
400056b0: 40 00 36 6c call 40013060 <strlen>
400056b4: 90 10 00 1d mov %i5, %o0
device_info->major = rtems_filesystem_dev_major_t( st.st_rdev );
400056b8: c2 07 bf b8 ld [ %fp + -72 ], %g1
400056bc: c2 26 60 08 st %g1, [ %i1 + 8 ]
rtems_status_code sc = RTEMS_SUCCESSFUL;
400056c0: b0 10 20 00 clr %i0
device_info->minor = rtems_filesystem_dev_minor_t( st.st_rdev );
400056c4: c2 07 bf bc ld [ %fp + -68 ], %g1
device_info->device_name_length = strlen( name );
400056c8: d0 26 60 04 st %o0, [ %i1 + 4 ]
device_info->minor = rtems_filesystem_dev_minor_t( st.st_rdev );
400056cc: c2 26 60 0c st %g1, [ %i1 + 0xc ]
} else {
sc = RTEMS_UNSATISFIED;
}
return sc;
}
400056d0: 81 c7 e0 08 ret
400056d4: 81 e8 00 00 restore
4000cb98 <rtems_tarfs_load>:
int rtems_tarfs_load(
const char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
4000cb98: 9d e3 bd 78 save %sp, -648, %sp
<== NOT EXECUTED
unsigned long nblocks;
int rv = 0;
int eval_flags = RTEMS_FS_FOLLOW_LINK;
rtems_filesystem_eval_path_context_t ctx;
rtems_filesystem_location_info_t rootloc;
rtems_filesystem_location_info_t *currentloc =
4000cb9c: 94 10 20 18 mov 0x18, %o2
<== NOT EXECUTED
4000cba0: 92 10 00 18 mov %i0, %o1
<== NOT EXECUTED
4000cba4: 40 00 1a fe call 4001379c <rtems_filesystem_eval_path_start>
<== NOT EXECUTED
4000cba8: 90 07 be 00 add %fp, -512, %o0
<== NOT EXECUTED
rtems_filesystem_location_copy_and_detach(
4000cbac: 92 07 be 18 add %fp, -488, %o1
4000cbb0: aa 10 00 08 mov %o0, %l5
4000cbb4: 40 00 1c 93 call 40013e00 <rtems_filesystem_location_copy_and_detach>
4000cbb8: 90 07 bd e8 add %fp, -536, %o0
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
4000cbbc: c2 07 bd fc ld [ %fp + -516 ], %g1
4000cbc0: c2 00 60 0c ld [ %g1 + 0xc ], %g1
ctx->flags = flags;
4000cbc4: 84 10 20 60 mov 0x60, %g2
4000cbc8: c4 27 be 10 st %g2, [ %fp + -496 ]
rtems_filesystem_eval_path_set_flags(
&ctx,
RTEMS_FS_MAKE | RTEMS_FS_EXCLUSIVE
);
if ( !IMFS_is_imfs_instance( &rootloc ) ) {
4000cbcc: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
4000cbd0: 03 10 00 36 sethi %hi(0x4000d800), %g1
4000cbd4: 82 10 63 18 or %g1, 0x318, %g1 ! 4000db18 <IMFS_node_clone>
4000cbd8: 80 a0 80 01 cmp %g2, %g1
4000cbdc: 02 80 00 0a be 4000cc04 <rtems_tarfs_load+0x6c>
4000cbe0: 2f 10 01 8f sethi %hi(0x40063c00), %l7
rv = -1;
4000cbe4: b8 10 3f ff mov -1, %i4
rv = symlink(linkto, full_filename);
}
}
rtems_filesystem_location_free( &rootloc );
4000cbe8: 40 00 13 d3 call 40011b34 <rtems_filesystem_location_free>
4000cbec: 90 07 bd e8 add %fp, -536, %o0
rtems_filesystem_eval_path_cleanup( &ctx );
4000cbf0: 90 07 be 00 add %fp, -512, %o0
4000cbf4: 40 00 1b 34 call 400138c4 <rtems_filesystem_eval_path_cleanup>
4000cbf8: b0 10 00 1c mov %i4, %i0
return rv;
}
4000cbfc: 81 c7 e0 08 ret
4000cc00: 81 e8 00 00 restore
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
4000cc04: 82 15 e1 e0 or %l7, 0x1e0, %g1
4000cc08: c2 27 bd e4 st %g1, [ %fp + -540 ]
IMFS_linearfile_t *linfile = (IMFS_linearfile_t *)
4000cc0c: 03 10 01 92 sethi %hi(0x40064800), %g1
4000cc10: 82 10 61 4c or %g1, 0x14c, %g1 ! 4006494c <IMFS_node_control_linfile>
4000cc14: c2 27 bd e0 st %g1, [ %fp + -544 ]
if (strncmp(&hdr_ptr[257], "ustar", 5))
4000cc18: 29 10 01 8d sethi %hi(0x40063400), %l4
4000cc1c: ba 10 20 00 clr %i5
4000cc20: a8 15 22 30 or %l4, 0x230, %l4
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
4000cc24: a4 07 be 98 add %fp, -360, %l2
strncpy(full_filename, mountpoint, 255);
4000cc28: a2 07 bf 00 add %fp, -256, %l1
if (offset + 512 > tar_size)
4000cc2c: b6 07 62 00 add %i5, 0x200, %i3
4000cc30: 80 a6 c0 1a cmp %i3, %i2
4000cc34: 18 80 00 2c bgu 4000cce4 <rtems_tarfs_load+0x14c>
<== NEVER TAKEN
4000cc38: 2d 00 00 20 sethi %hi(0x8000), %l6
hdr_ptr = (char *) &tar_image[offset];
4000cc3c: ba 06 40 1d add %i1, %i5, %i5
if (strncmp(&hdr_ptr[257], "ustar", 5))
4000cc40: 94 10 20 05 mov 5, %o2
4000cc44: 92 10 00 14 mov %l4, %o1
4000cc48: 40 00 f1 da call 400493b0 <strncmp>
4000cc4c: 90 07 61 01 add %i5, 0x101, %o0
4000cc50: 80 a2 20 00 cmp %o0, 0
4000cc54: 12 80 00 24 bne 4000cce4 <rtems_tarfs_load+0x14c>
4000cc58: 94 10 20 63 mov 0x63, %o2
strncpy(filename, hdr_ptr, MAX_NAME_FIELD_SIZE);
4000cc5c: 92 10 00 1d mov %i5, %o1
4000cc60: 40 00 f2 1e call 400494d8 <strncpy>
4000cc64: 90 10 00 12 mov %l2, %o0
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
4000cc68: 92 10 20 08 mov 8, %o1
filename[MAX_NAME_FIELD_SIZE] = '\0';
4000cc6c: c0 2f be fb clrb [ %fp + -261 ]
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
4000cc70: 90 07 60 64 add %i5, 0x64, %o0
4000cc74: 40 00 6b c8 call 40027b94 <_rtems_octal2ulong>
4000cc78: f8 0f 60 9c ldub [ %i5 + 0x9c ], %i4
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
4000cc7c: 92 10 20 0c mov 0xc, %o1
file_mode = _rtems_octal2ulong(&hdr_ptr[100], 8);
4000cc80: a6 10 00 08 mov %o0, %l3
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
4000cc84: 40 00 6b c4 call 40027b94 <_rtems_octal2ulong>
4000cc88: 90 07 60 7c add %i5, 0x7c, %o0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
4000cc8c: 92 10 20 08 mov 8, %o1
file_size = _rtems_octal2ulong(&hdr_ptr[124], 12);
4000cc90: a0 10 00 08 mov %o0, %l0
hdr_chksum = _rtems_octal2ulong(&hdr_ptr[148], 8);
4000cc94: 40 00 6b c0 call 40027b94 <_rtems_octal2ulong>
4000cc98: 90 07 60 94 add %i5, 0x94, %o0
4000cc9c: ae 10 00 08 mov %o0, %l7
if (_rtems_tar_header_checksum(hdr_ptr) != hdr_chksum)
4000cca0: 40 00 6b d3 call 40027bec <_rtems_tar_header_checksum>
4000cca4: 90 10 00 1d mov %i5, %o0
4000cca8: 80 a2 00 17 cmp %o0, %l7
4000ccac: 12 80 00 0e bne 4000cce4 <rtems_tarfs_load+0x14c>
<== NEVER TAKEN
4000ccb0: b8 0f 20 ff and %i4, 0xff, %i4
if (linkflag == DIRTYPE) {
4000ccb4: 80 a7 20 35 cmp %i4, 0x35
4000ccb8: 02 80 00 2e be 4000cd70 <rtems_tarfs_load+0x1d8>
4000ccbc: 80 a7 20 30 cmp %i4, 0x30
else if (linkflag == REGTYPE) {
4000ccc0: 02 80 00 63 be 4000ce4c <rtems_tarfs_load+0x2b4>
4000ccc4: 80 a7 20 32 cmp %i4, 0x32
else if (linkflag == SYMTYPE) {
4000ccc8: 02 80 00 0f be 4000cd04 <rtems_tarfs_load+0x16c>
<== ALWAYS TAKEN
4000cccc: 94 10 20 ff mov 0xff, %o2
{
4000ccd0: ba 10 00 1b mov %i3, %i5
<== NOT EXECUTED
if (offset + 512 > tar_size)
4000ccd4: b6 07 62 00 add %i5, 0x200, %i3
4000ccd8: 80 a6 c0 1a cmp %i3, %i2
4000ccdc: 28 bf ff d9 bleu,a 4000cc40 <rtems_tarfs_load+0xa8>
<== ALWAYS TAKEN
4000cce0: ba 06 40 1d add %i1, %i5, %i5
rtems_filesystem_location_free( &rootloc );
4000cce4: 40 00 13 94 call 40011b34 <rtems_filesystem_location_free>
4000cce8: 90 07 bd e8 add %fp, -536, %o0
4000ccec: b8 10 20 00 clr %i4
rtems_filesystem_eval_path_cleanup( &ctx );
4000ccf0: 90 07 be 00 add %fp, -512, %o0
4000ccf4: 40 00 1a f4 call 400138c4 <rtems_filesystem_eval_path_cleanup>
4000ccf8: b0 10 00 1c mov %i4, %i0
}
4000ccfc: 81 c7 e0 08 ret
4000cd00: 81 e8 00 00 restore
strncpy(full_filename, mountpoint, 255);
4000cd04: 92 10 00 18 mov %i0, %o1
4000cd08: 40 00 f1 f4 call 400494d8 <strncpy>
4000cd0c: 90 10 00 11 mov %l1, %o0
if (full_filename[(len=strlen(full_filename))-1] != '/')
4000cd10: 40 00 f1 48 call 40049230 <strlen>
4000cd14: 90 10 00 11 mov %l1, %o0
4000cd18: 82 07 80 08 add %fp, %o0, %g1
4000cd1c: c2 48 7e ff ldsb [ %g1 + -257 ], %g1
4000cd20: 80 a0 60 2f cmp %g1, 0x2f
4000cd24: 02 80 00 06 be 4000cd3c <rtems_tarfs_load+0x1a4>
<== ALWAYS TAKEN
4000cd28: ba 07 60 9d add %i5, 0x9d, %i5
strcat(full_filename, "/");
4000cd2c: 82 10 20 2f mov 0x2f, %g1
<== NOT EXECUTED
4000cd30: c2 2c 40 08 stb %g1, [ %l1 + %o0 ]
<== NOT EXECUTED
4000cd34: 82 04 40 08 add %l1, %o0, %g1
<== NOT EXECUTED
4000cd38: c0 28 60 01 clrb [ %g1 + 1 ]
<== NOT EXECUTED
strncat(full_filename, filename, 256-len-1);
4000cd3c: 92 10 00 12 mov %l2, %o1
4000cd40: 94 10 20 fe mov 0xfe, %o2
4000cd44: 94 22 80 08 sub %o2, %o0, %o2
4000cd48: 40 00 f1 6a call 400492f0 <strncat>
4000cd4c: 90 10 00 11 mov %l1, %o0
rv = symlink(linkto, full_filename);
4000cd50: 90 10 00 1d mov %i5, %o0
4000cd54: 92 10 00 11 mov %l1, %o1
4000cd58: 40 00 1c d8 call 400140b8 <symlink>
4000cd5c: ba 10 00 1b mov %i3, %i5
while ( rv == 0 ) {
4000cd60: 80 a2 20 00 cmp %o0, 0
4000cd64: 02 bf ff b2 be 4000cc2c <rtems_tarfs_load+0x94>
<== ALWAYS TAKEN
4000cd68: b8 10 00 08 mov %o0, %i4
4000cd6c: 30 bf ff 9f b,a 4000cbe8 <rtems_tarfs_load+0x50>
<== NOT EXECUTED
strncpy(full_filename, mountpoint, 255);
4000cd70: 94 10 20 ff mov 0xff, %o2
4000cd74: 92 10 00 18 mov %i0, %o1
4000cd78: 40 00 f1 d8 call 400494d8 <strncpy>
4000cd7c: 90 10 00 11 mov %l1, %o0
if (full_filename[(len=strlen(full_filename))-1] != '/')
4000cd80: 40 00 f1 2c call 40049230 <strlen>
4000cd84: 90 10 00 11 mov %l1, %o0
4000cd88: 84 07 80 08 add %fp, %o0, %g2
4000cd8c: c4 48 be ff ldsb [ %g2 + -257 ], %g2
4000cd90: 80 a0 a0 2f cmp %g2, 0x2f
4000cd94: 02 80 00 06 be 4000cdac <rtems_tarfs_load+0x214>
<== ALWAYS TAKEN
4000cd98: 82 10 00 08 mov %o0, %g1
strcat(full_filename, "/");
4000cd9c: 84 10 20 2f mov 0x2f, %g2
<== NOT EXECUTED
4000cda0: c4 2c 40 08 stb %g2, [ %l1 + %o0 ]
<== NOT EXECUTED
4000cda4: 84 04 40 08 add %l1, %o0, %g2
<== NOT EXECUTED
4000cda8: c0 28 a0 01 clrb [ %g2 + 1 ]
<== NOT EXECUTED
strncat(full_filename, filename, 256-len-1);
4000cdac: 92 10 00 12 mov %l2, %o1
4000cdb0: 90 10 00 11 mov %l1, %o0
4000cdb4: 94 10 20 fe mov 0xfe, %o2
4000cdb8: 40 00 f1 4e call 400492f0 <strncat>
4000cdbc: 94 22 80 01 sub %o2, %g1, %o2
if ( mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO) != 0 ) {
4000cdc0: 92 10 21 ff mov 0x1ff, %o1
4000cdc4: 40 00 14 ed call 40012178 <mkdir>
4000cdc8: 90 10 00 11 mov %l1, %o0
4000cdcc: 80 a2 20 00 cmp %o0, 0
4000cdd0: 02 bf ff c1 be 4000ccd4 <rtems_tarfs_load+0x13c>
<== ALWAYS TAKEN
4000cdd4: ba 10 00 1b mov %i3, %i5
if (errno == EEXIST) {
4000cdd8: 40 00 d4 ef call 40042194 <__errno>
<== NOT EXECUTED
4000cddc: 01 00 00 00 nop
<== NOT EXECUTED
4000cde0: c2 02 00 00 ld [ %o0 ], %g1
<== NOT EXECUTED
4000cde4: 80 a0 60 11 cmp %g1, 0x11
<== NOT EXECUTED
4000cde8: 12 bf ff 7f bne 4000cbe4 <rtems_tarfs_load+0x4c>
<== NOT EXECUTED
4000cdec: 92 07 be 38 add %fp, -456, %o1
<== NOT EXECUTED
if ( stat(full_filename, &stat_buf) == 0 ) {
4000cdf0: 40 00 18 cc call 40013120 <stat>
<== NOT EXECUTED
4000cdf4: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
4000cdf8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000cdfc: 12 bf ff 7a bne 4000cbe4 <rtems_tarfs_load+0x4c>
<== NOT EXECUTED
4000ce00: 05 00 00 3c sethi %hi(0xf000), %g2
<== NOT EXECUTED
if ( S_ISDIR(stat_buf.st_mode) ) {
4000ce04: c2 07 be 44 ld [ %fp + -444 ], %g1
<== NOT EXECUTED
4000ce08: 82 08 40 02 and %g1, %g2, %g1
<== NOT EXECUTED
4000ce0c: 05 00 00 10 sethi %hi(0x4000), %g2
<== NOT EXECUTED
4000ce10: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4000ce14: 02 bf ff b0 be 4000ccd4 <rtems_tarfs_load+0x13c>
<== NOT EXECUTED
4000ce18: ba 10 00 1b mov %i3, %i5
<== NOT EXECUTED
if ( unlink(full_filename) != -1 ) {
4000ce1c: 40 00 1c b8 call 400140fc <unlink>
<== NOT EXECUTED
4000ce20: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
4000ce24: 80 a2 3f ff cmp %o0, -1
<== NOT EXECUTED
4000ce28: 02 bf ff 6f be 4000cbe4 <rtems_tarfs_load+0x4c>
<== NOT EXECUTED
4000ce2c: 92 10 21 ff mov 0x1ff, %o1
<== NOT EXECUTED
if ( mkdir(full_filename, S_IRWXU | S_IRWXG | S_IRWXO) == 0 )
4000ce30: 40 00 14 d2 call 40012178 <mkdir>
<== NOT EXECUTED
4000ce34: 90 10 00 11 mov %l1, %o0
<== NOT EXECUTED
4000ce38: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000ce3c: 12 bf ff 6a bne 4000cbe4 <rtems_tarfs_load+0x4c>
<== NOT EXECUTED
4000ce40: ba 10 00 1b mov %i3, %i5
<== NOT EXECUTED
if (offset + 512 > tar_size)
4000ce44: 10 bf ff a5 b 4000ccd8 <rtems_tarfs_load+0x140>
<== NOT EXECUTED
4000ce48: b6 07 62 00 add %i5, 0x200, %i3
<== NOT EXECUTED
rtems_filesystem_location_free( currentloc );
4000ce4c: 40 00 13 3a call 40011b34 <rtems_filesystem_location_free>
4000ce50: 90 10 00 15 mov %l5, %o0
rtems_filesystem_location_clone( currentloc, &rootloc );
4000ce54: 92 07 bd e8 add %fp, -536, %o1
4000ce58: 40 00 11 a7 call 400114f4 <rtems_filesystem_location_clone>
4000ce5c: 90 10 00 15 mov %l5, %o0
rtems_filesystem_eval_path_set_path(
4000ce60: 40 00 f0 f4 call 40049230 <strlen>
4000ce64: 90 10 00 12 mov %l2, %o0
ctx->path = path;
4000ce68: e4 27 be 00 st %l2, [ %fp + -512 ]
ctx->pathlen = pathlen;
4000ce6c: d0 27 be 04 st %o0, [ %fp + -508 ]
rtems_filesystem_eval_path_continue( &ctx );
4000ce70: 40 00 19 d8 call 400135d0 <rtems_filesystem_eval_path_continue>
4000ce74: 90 07 be 00 add %fp, -512, %o0
if ( !rtems_filesystem_location_is_null( currentloc ) ) {
4000ce78: c2 05 60 10 ld [ %l5 + 0x10 ], %g1
4000ce7c: c4 07 bd e4 ld [ %fp + -540 ], %g2
4000ce80: 80 a0 40 02 cmp %g1, %g2
4000ce84: 02 80 00 0f be 4000cec0 <rtems_tarfs_load+0x328>
<== NEVER TAKEN
4000ce88: 9a 0c e1 ff and %l3, 0x1ff, %o5
IMFS_linearfile_t *linfile = (IMFS_linearfile_t *)
4000ce8c: c0 23 a0 5c clr [ %sp + 0x5c ]
4000ce90: d8 07 be 0c ld [ %fp + -500 ], %o4
4000ce94: d6 07 be 08 ld [ %fp + -504 ], %o3
4000ce98: d2 07 bd e0 ld [ %fp + -544 ], %o1
4000ce9c: 9a 13 40 16 or %o5, %l6, %o5
4000cea0: 94 10 20 58 mov 0x58, %o2
4000cea4: 40 00 6d a3 call 40028530 <IMFS_create_node>
4000cea8: 90 10 00 15 mov %l5, %o0
if ( linfile != NULL ) {
4000ceac: 80 a2 20 00 cmp %o0, 0
4000ceb0: 02 80 00 04 be 4000cec0 <rtems_tarfs_load+0x328>
<== NEVER TAKEN
4000ceb4: 82 06 40 1b add %i1, %i3, %g1
linfile->File.size = file_size;
4000ceb8: e0 22 20 40 st %l0, [ %o0 + 0x40 ]
linfile->direct = &tar_image[offset];
4000cebc: c2 22 20 48 st %g1, [ %o0 + 0x48 ]
nblocks = (((file_size) + 511) & ~511) / 512;
4000cec0: a0 04 21 ff add %l0, 0x1ff, %l0
offset += 512 * nblocks;
4000cec4: a0 0c 3e 00 and %l0, -512, %l0
4000cec8: b6 04 00 1b add %l0, %i3, %i3
{
4000cecc: 10 bf ff 82 b 4000ccd4 <rtems_tarfs_load+0x13c>
4000ced0: ba 10 00 1b mov %i3, %i5