40023810 <IMFS_LIMITS_AND_OPTIONS>:
40023810: 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00 ff ................
40023820: 00 00 00 ff 00 00 00 02 00 00 00 01 00 00 00 02 ................
40023830: 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00 06 ................
40023840: 28 64 65 66 61 75 6c 74 29 00 00 00 (default)...
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
/*
* 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
4000c38c: c4 00 60 08 ld [ %g1 + 8 ], %g2
4000c390: f6 00 40 00 ld [ %g1 ], %i3
4000c394: f8 00 60 04 ld [ %g1 + 4 ], %i4
4000c398: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4000c39c: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
4000c3a0: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
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
40002eec <IMFS_initialize>:
int IMFS_initialize(
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
40002eec: 9d e3 bf 90 save %sp, -112, %sp
IMFS_fs_info_t *fs_info = calloc( 1, sizeof( *fs_info ) );
40002ef0: 92 10 20 58 mov 0x58, %o1
40002ef4: 40 00 05 1f call 40004370 <calloc>
40002ef8: 90 10 20 01 mov 1, %o0
IMFS_mount_data mount_data = {
40002efc: 03 10 00 40 sethi %hi(0x40010000), %g1
40002f00: 82 10 60 5c or %g1, 0x5c, %g1 ! 4001005c <IMFS_ops>
40002f04: d0 27 bf f4 st %o0, [ %fp + -12 ]
.fs_info = fs_info,
.ops = &IMFS_ops,
.mknod_controls = &IMFS_default_mknod_controls
};
if ( fs_info == NULL ) {
40002f08: 80 a2 20 00 cmp %o0, 0
IMFS_mount_data mount_data = {
40002f0c: c2 27 bf f8 st %g1, [ %fp + -8 ]
40002f10: 03 10 00 40 sethi %hi(0x40010000), %g1
40002f14: 82 10 60 4c or %g1, 0x4c, %g1 ! 4001004c <IMFS_default_mknod_controls>
if ( fs_info == NULL ) {
40002f18: 02 80 00 07 be 40002f34 <IMFS_initialize+0x48>
<== NEVER TAKEN
40002f1c: c2 27 bf fc st %g1, [ %fp + -4 ]
rtems_set_errno_and_return_minus_one( ENOMEM );
}
return IMFS_initialize_support( mt_entry, &mount_data );
40002f20: 92 07 bf f4 add %fp, -12, %o1
40002f24: 40 00 00 11 call 40002f68 <IMFS_initialize_support>
40002f28: 90 10 00 18 mov %i0, %o0
}
40002f2c: 81 c7 e0 08 ret
40002f30: 91 e8 00 08 restore %g0, %o0, %o0
rtems_set_errno_and_return_minus_one( ENOMEM );
40002f34: 40 00 2b e6 call 4000decc <__errno>
<== NOT EXECUTED
40002f38: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40002f3c: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40002f40: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40002f44: 81 c7 e0 08 ret
<== NOT EXECUTED
40002f48: 81 e8 00 00 restore
<== NOT EXECUTED
40006a98 <IMFS_initialize_node>:
const char *name,
size_t namelen,
mode_t mode,
void *arg
)
{
40006a98: 9d e3 bf 90 save %sp, -112, %sp
struct timeval tv;
if ( namelen > IMFS_NAME_MAX ) {
40006a9c: 80 a6 e0 ff cmp %i3, 0xff
40006aa0: 18 80 00 19 bgu 40006b04 <IMFS_initialize_node+0x6c>
<== NEVER TAKEN
40006aa4: 92 10 20 00 clr %o1
errno = ENAMETOOLONG;
return NULL;
}
gettimeofday( &tv, 0 );
40006aa8: 40 00 02 23 call 40007334 <gettimeofday>
40006aac: 90 07 bf f0 add %fp, -16, %o0
/*
* Fill in the basic information
*/
node->name = name;
node->namelen = namelen;
node->reference_count = 1;
40006ab0: 03 00 00 40 sethi %hi(0x10000), %g1
node->name = name;
40006ab4: f4 26 20 0c st %i2, [ %i0 + 0xc ]
node->reference_count = 1;
40006ab8: 82 10 60 01 or %g1, 1, %g1
node->namelen = namelen;
40006abc: f6 36 20 10 sth %i3, [ %i0 + 0x10 ]
node->reference_count = 1;
40006ac0: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
node->st_nlink = 1;
node->control = node_control;
40006ac4: 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();
40006ac8: 40 00 02 15 call 4000731c <geteuid>
40006acc: f8 26 20 14 st %i4, [ %i0 + 0x14 ]
node->st_gid = getegid();
40006ad0: 40 00 02 0d call 40007304 <getegid>
40006ad4: d0 36 20 1c sth %o0, [ %i0 + 0x1c ]
/*
* Now set all the times.
*/
node->stat_atime = (time_t) tv.tv_sec;
40006ad8: c4 1f bf f0 ldd [ %fp + -16 ], %g2
node->st_gid = getegid();
40006adc: 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 );
40006ae0: 92 10 00 1d mov %i5, %o1
node->stat_atime = (time_t) tv.tv_sec;
40006ae4: c4 3e 20 20 std %g2, [ %i0 + 0x20 ]
node->stat_mtime = (time_t) tv.tv_sec;
40006ae8: c4 3e 20 28 std %g2, [ %i0 + 0x28 ]
node->stat_ctime = (time_t) tv.tv_sec;
40006aec: c4 3e 20 30 std %g2, [ %i0 + 0x30 ]
return (*node_control->node_initialize)( node, arg );
40006af0: c2 06 60 04 ld [ %i1 + 4 ], %g1
40006af4: 9f c0 40 00 call %g1
40006af8: 90 10 00 18 mov %i0, %o0
}
40006afc: 81 c7 e0 08 ret
40006b00: 91 e8 00 08 restore %g0, %o0, %o0
errno = ENAMETOOLONG;
40006b04: 40 00 38 f1 call 40014ec8 <__errno>
<== NOT EXECUTED
40006b08: b0 10 20 00 clr %i0
<== NOT EXECUTED
40006b0c: 82 10 20 5b mov 0x5b, %g1
<== NOT EXECUTED
40006b10: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return NULL;
40006b14: 81 c7 e0 08 ret
<== NOT EXECUTED
40006b18: 81 e8 00 00 restore
<== NOT EXECUTED
40005b64 <IMFS_initialize_support>:
{
40005b64: 9d e3 bf a0 save %sp, -96, %sp
IMFS_fs_info_t *fs_info = mount_data->fs_info;
40005b68: fa 06 40 00 ld [ %i1 ], %i5
fs_info->mknod_controls = mount_data->mknod_controls;
40005b6c: c2 06 60 08 ld [ %i1 + 8 ], %g1
40005b70: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
root_node = IMFS_initialize_node(
40005b74: 9a 10 20 00 clr %o5
40005b78: d2 00 40 00 ld [ %g1 ], %o1
40005b7c: 96 10 20 00 clr %o3
40005b80: 19 00 00 10 sethi %hi(0x4000), %o4
40005b84: 90 10 00 1d mov %i5, %o0
40005b88: 98 13 21 ed or %o4, 0x1ed, %o4
40005b8c: 15 10 00 8b sethi %hi(0x40022c00), %o2
40005b90: 40 00 03 c2 call 40006a98 <IMFS_initialize_node>
40005b94: 94 12 a2 e0 or %o2, 0x2e0, %o2 ! 40022ee0 <rtems_test_name+0x108>
mt_entry->ops = mount_data->ops;
40005b98: c2 06 60 04 ld [ %i1 + 4 ], %g1
loc->handlers = node->control->handlers;
40005b9c: c4 02 20 38 ld [ %o0 + 0x38 ], %g2
40005ba0: c2 26 20 0c st %g1, [ %i0 + 0xc ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
40005ba4: 03 10 00 8e sethi %hi(0x40023800), %g1
40005ba8: 82 10 60 10 or %g1, 0x10, %g1 ! 40023810 <IMFS_LIMITS_AND_OPTIONS>
mt_entry->fs_info = fs_info;
40005bac: fa 26 20 08 st %i5, [ %i0 + 8 ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
40005bb0: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
40005bb4: c4 00 80 00 ld [ %g2 ], %g2
mt_entry->mt_fs_root->location.node_access = root_node;
40005bb8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40005bbc: d0 20 60 08 st %o0, [ %g1 + 8 ]
40005bc0: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
IMFS_determine_bytes_per_block(
40005bc4: 03 10 00 94 sethi %hi(0x40025000), %g1
40005bc8: c6 00 60 80 ld [ %g1 + 0x80 ], %g3 ! 40025080 <imfs_rq_memfile_bytes_per_block>
if (bit_mask == requested_bytes_per_block) {
40005bcc: 80 a0 e0 10 cmp %g3, 0x10
40005bd0: 02 80 00 0e be 40005c08 <IMFS_initialize_support+0xa4> <== NEVER TAKEN
40005bd4: 80 a0 e0 0f cmp %g3, 0xf
if(bit_mask > requested_bytes_per_block)
40005bd8: 04 80 00 0b ble 40005c04 <IMFS_initialize_support+0xa0> <== NEVER TAKEN
40005bdc: 82 10 20 20 mov 0x20, %g1
40005be0: 84 10 20 05 mov 5, %g2
if (bit_mask == requested_bytes_per_block) {
40005be4: 80 a0 c0 01 cmp %g3, %g1
40005be8: 22 80 00 09 be,a 40005c0c <IMFS_initialize_support+0xa8>
40005bec: 03 10 00 9b sethi %hi(0x40026c00), %g1
if(bit_mask > requested_bytes_per_block)
40005bf0: 26 80 00 06 bl,a 40005c08 <IMFS_initialize_support+0xa4> <== NEVER TAKEN
40005bf4: 86 10 20 80 mov 0x80, %g3
<== NOT EXECUTED
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
40005bf8: 84 80 bf ff addcc %g2, -1, %g2
40005bfc: 12 bf ff fa bne 40005be4 <IMFS_initialize_support+0x80> <== ALWAYS TAKEN
40005c00: 83 28 60 01 sll %g1, 1, %g1
: default_bytes_per_block);
40005c04: 86 10 20 80 mov 0x80, %g3
<== NOT EXECUTED
*dest_bytes_per_block = ((is_valid)
40005c08: 03 10 00 9b sethi %hi(0x40026c00), %g1
<== NOT EXECUTED
40005c0c: c6 20 60 1c st %g3, [ %g1 + 0x1c ] ! 40026c1c <imfs_memfile_bytes_per_block>
}
40005c10: 81 c7 e0 08 ret
40005c14: 91 e8 20 00 restore %g0, 0, %o0
40005d04 <IMFS_link>:
{
40005d04: 9d e3 bf 88 save %sp, -120, %sp
target = targetloc->node_access;
40005d08: fa 06 60 08 ld [ %i1 + 8 ], %i5
if ( target->st_nlink >= LINK_MAX )
40005d0c: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
40005d10: 80 a0 60 07 cmp %g1, 7
40005d14: 18 80 00 19 bgu 40005d78 <IMFS_link+0x74>
<== NEVER TAKEN
40005d18: 9a 10 21 ff mov 0x1ff, %o5
new_node = IMFS_create_node(
40005d1c: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
40005d20: 98 10 00 1b mov %i3, %o4
40005d24: 96 10 00 1a mov %i2, %o3
40005d28: 94 10 20 48 mov 0x48, %o2
40005d2c: 90 10 00 18 mov %i0, %o0
40005d30: 13 10 00 8c sethi %hi(0x40023000), %o1
40005d34: 40 00 34 d7 call 40013090 <IMFS_create_node>
40005d38: 92 12 62 44 or %o1, 0x244, %o1 ! 40023244 <IMFS_node_control_hard_link>
if ( !new_node )
40005d3c: 80 a2 20 00 cmp %o0, 0
40005d40: 02 80 00 14 be 40005d90 <IMFS_link+0x8c>
<== NEVER TAKEN
40005d44: 90 07 bf f0 add %fp, -16, %o0
target->reference_count++;
40005d48: c4 17 60 18 lduh [ %i5 + 0x18 ], %g2
target->st_nlink++;
40005d4c: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
target->reference_count++;
40005d50: 84 00 a0 01 inc %g2
target->st_nlink++;
40005d54: 82 00 60 01 inc %g1
target->reference_count++;
40005d58: c4 37 60 18 sth %g2, [ %i5 + 0x18 ]
target->st_nlink++;
40005d5c: c2 37 60 1a sth %g1, [ %i5 + 0x1a ]
_Timecounter_Getbintime( &now );
40005d60: 40 00 16 80 call 4000b760 <_Timecounter_Getbintime>
40005d64: b0 10 20 00 clr %i0
return now.sec;
40005d68: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_ctime = _IMFS_get_time();
40005d6c: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
}
40005d70: 81 c7 e0 08 ret
40005d74: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EMLINK );
40005d78: 40 00 3c 54 call 40014ec8 <__errno>
<== NOT EXECUTED
40005d7c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005d80: 82 10 20 1f mov 0x1f, %g1
<== NOT EXECUTED
40005d84: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005d88: 81 c7 e0 08 ret
<== NOT EXECUTED
40005d8c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
40005d90: 40 00 3c 4e call 40014ec8 <__errno>
<== NOT EXECUTED
40005d94: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40005d98: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40005d9c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005da0: 81 c7 e0 08 ret
<== NOT EXECUTED
40005da4: 81 e8 00 00 restore
<== NOT EXECUTED
40005db0 <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
40005db0: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
40005db4: 40 00 08 de call 4000812c <rtems_current_user_env_get>
40005db8: 01 00 00 00 nop
40005dbc: da 02 20 08 ld [ %o0 + 8 ], %o5
40005dc0: b2 2e 40 0d andn %i1, %o5, %i1
switch (mode & S_IFMT) {
40005dc4: 03 00 00 3c sethi %hi(0xf000), %g1
40005dc8: 05 00 00 18 sethi %hi(0x6000), %g2
40005dcc: 82 0e 40 01 and %i1, %g1, %g1
40005dd0: 80 a0 40 02 cmp %g1, %g2
40005dd4: 02 80 00 0c be 40005e04 <IMFS_make_generic_node+0x54>
40005dd8: 94 10 20 78 mov 0x78, %o2
40005ddc: 08 80 00 1d bleu 40005e50 <IMFS_make_generic_node+0xa0> <== ALWAYS TAKEN
40005de0: 05 00 00 04 sethi %hi(0x1000), %g2
40005de4: 05 00 00 20 sethi %hi(0x8000), %g2
<== NOT EXECUTED
40005de8: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40005dec: 02 80 00 06 be 40005e04 <IMFS_make_generic_node+0x54>
<== NOT EXECUTED
40005df0: 05 00 00 30 sethi %hi(0xc000), %g2
<== NOT EXECUTED
40005df4: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40005df8: 12 80 00 1c bne 40005e68 <IMFS_make_generic_node+0xb8>
<== NOT EXECUTED
40005dfc: 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 =
40005e00: 94 10 20 78 mov 0x78, %o2 ! 78 <_TLS_Alignment+0x77>
<== NOT EXECUTED
40005e04: 92 10 00 18 mov %i0, %o1
40005e08: 40 00 0b 5f call 40008b84 <rtems_filesystem_eval_path_start>
40005e0c: 90 07 bf c8 add %fp, -56, %o0
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
40005e10: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40005e14: c2 00 60 0c ld [ %g1 + 0xc ], %g1
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
40005e18: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
40005e1c: 03 10 00 1a sethi %hi(0x40006800), %g1
40005e20: 82 10 63 1c or %g1, 0x31c, %g1 ! 40006b1c <IMFS_node_clone>
40005e24: 80 a0 80 01 cmp %g2, %g1
40005e28: 02 80 00 16 be 40005e80 <IMFS_make_generic_node+0xd0>
40005e2c: ba 10 00 08 mov %o0, %i5
IMFS_mtime_ctime_update( parent );
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
40005e30: 92 10 20 86 mov 0x86, %o1
40005e34: 90 07 bf c8 add %fp, -56, %o0
40005e38: 40 00 0a 98 call 40008898 <rtems_filesystem_eval_path_error>
40005e3c: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40005e40: 40 00 0b 9b call 40008cac <rtems_filesystem_eval_path_cleanup>
40005e44: 90 07 bf c8 add %fp, -56, %o0
}
return rv;
}
40005e48: 81 c7 e0 08 ret
40005e4c: 81 e8 00 00 restore
switch (mode & S_IFMT) {
40005e50: 80 a0 40 02 cmp %g1, %g2
40005e54: 02 bf ff eb be 40005e00 <IMFS_make_generic_node+0x50>
<== NEVER TAKEN
40005e58: 05 00 00 08 sethi %hi(0x2000), %g2
40005e5c: 80 a0 40 02 cmp %g1, %g2
40005e60: 02 bf ff e9 be 40005e04 <IMFS_make_generic_node+0x54>
40005e64: 94 10 20 78 mov 0x78, %o2
errno = EINVAL;
40005e68: 40 00 3c 18 call 40014ec8 <__errno>
40005e6c: b0 10 3f ff mov -1, %i0
40005e70: 82 10 20 16 mov 0x16, %g1
40005e74: c2 22 00 00 st %g1, [ %o0 ]
40005e78: 81 c7 e0 08 ret
40005e7c: 81 e8 00 00 restore
IMFS_jnode_t *new_node = IMFS_create_node(
40005e80: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
40005e84: 9a 10 00 19 mov %i1, %o5
40005e88: d8 07 bf d4 ld [ %fp + -44 ], %o4
40005e8c: d6 07 bf d0 ld [ %fp + -48 ], %o3
40005e90: 94 10 20 48 mov 0x48, %o2
40005e94: 92 10 00 1a mov %i2, %o1
40005e98: 40 00 34 7e call 40013090 <IMFS_create_node>
40005e9c: b0 10 3f ff mov -1, %i0
if ( new_node != NULL ) {
40005ea0: 80 a2 20 00 cmp %o0, 0
40005ea4: 02 bf ff e7 be 40005e40 <IMFS_make_generic_node+0x90>
40005ea8: 01 00 00 00 nop
IMFS_jnode_t *parent = currentloc->node_access;
40005eac: fa 07 60 08 ld [ %i5 + 8 ], %i5
_Timecounter_Getbintime( &now );
40005eb0: 40 00 16 2c call 4000b760 <_Timecounter_Getbintime>
40005eb4: 90 07 bf b8 add %fp, -72, %o0
return now.sec;
40005eb8: c4 1f bf b8 ldd [ %fp + -72 ], %g2
jnode->stat_mtime = now;
40005ebc: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
int rv = 0;
40005ec0: b0 10 20 00 clr %i0
jnode->stat_ctime = now;
40005ec4: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
rtems_filesystem_eval_path_cleanup( &ctx );
40005ec8: 40 00 0b 79 call 40008cac <rtems_filesystem_eval_path_cleanup>
40005ecc: 90 07 bf c8 add %fp, -56, %o0
}
40005ed0: 81 c7 e0 08 ret
40005ed4: 81 e8 00 00 restore
40006718 <IMFS_memfile_write>:
{
40006718: 9d e3 bf 90 save %sp, -112, %sp
if ( last_byte > memfile->File.size ) {
4000671c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
last_byte = start + my_length;
40006720: 96 07 00 1a add %i4, %i2, %o3
if ( last_byte > memfile->File.size ) {
40006724: 80 a0 40 0b cmp %g1, %o3
40006728: 0a 80 00 54 bcs 40006878 <IMFS_memfile_write+0x160>
4000672c: a0 10 00 18 mov %i0, %l0
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
40006730: 23 10 00 9b sethi %hi(0x40026c00), %l1
40006734: e4 04 60 1c ld [ %l1 + 0x1c ], %l2 ! 40026c1c <imfs_memfile_bytes_per_block>
40006738: bb 3c a0 1f sra %l2, 0x1f, %i5
4000673c: 96 10 00 12 mov %l2, %o3
40006740: 94 10 00 1d mov %i5, %o2
40006744: 92 10 00 1a mov %i2, %o1
40006748: 40 00 6d b1 call 40021e0c <__moddi3>
4000674c: 90 10 00 19 mov %i1, %o0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40006750: 94 10 00 1d mov %i5, %o2
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
40006754: a6 10 00 09 mov %o1, %l3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40006758: 96 10 00 12 mov %l2, %o3
4000675c: 92 10 00 1a mov %i2, %o1
40006760: 40 00 6d 20 call 40021be0 <__divdi3>
40006764: 90 10 00 19 mov %i1, %o0
40006768: ba 10 00 12 mov %l2, %i5
4000676c: b4 10 00 09 mov %o1, %i2
if ( start_offset ) {
40006770: 80 a4 e0 00 cmp %l3, 0
40006774: 12 80 00 1a bne 400067dc <IMFS_memfile_write+0xc4>
40006778: b0 10 20 00 clr %i0
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000677c: 80 a7 00 1d cmp %i4, %i5
40006780: 1a 80 00 0e bcc 400067b8 <IMFS_memfile_write+0xa0>
40006784: 92 10 00 1a mov %i2, %o1
if ( my_length ) {
40006788: 10 80 00 29 b 4000682c <IMFS_memfile_write+0x114>
4000678c: 80 a7 20 00 cmp %i4, 0
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
40006790: 40 00 3b a2 call 40015618 <memcpy>
40006794: d0 02 00 00 ld [ %o0 ], %o0
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40006798: c2 04 60 1c ld [ %l1 + 0x1c ], %g1
my_length -= to_copy;
4000679c: b8 27 00 1d sub %i4, %i5, %i4
src += to_copy;
400067a0: b6 06 c0 1d add %i3, %i5, %i3
block++;
400067a4: b4 06 a0 01 inc %i2
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
400067a8: 80 a0 40 1c cmp %g1, %i4
400067ac: 18 80 00 1f bgu 40006828 <IMFS_memfile_write+0x110>
400067b0: b0 06 00 1d add %i0, %i5, %i0
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
400067b4: 92 10 00 1a mov %i2, %o1
400067b8: 94 10 20 00 clr %o2
400067bc: 7f ff fd d4 call 40005f0c <IMFS_memfile_get_block_pointer>
400067c0: 90 10 00 10 mov %l0, %o0
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
400067c4: 92 10 00 1b mov %i3, %o1
if ( !block_ptr )
400067c8: 80 a2 20 00 cmp %o0, 0
400067cc: 12 bf ff f1 bne 40006790 <IMFS_memfile_write+0x78>
<== ALWAYS TAKEN
400067d0: 94 10 00 1d mov %i5, %o2
}
400067d4: 81 c7 e0 08 ret
<== NOT EXECUTED
400067d8: 81 e8 00 00 restore
<== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
400067dc: 94 10 20 00 clr %o2
400067e0: 7f ff fd cb call 40005f0c <IMFS_memfile_get_block_pointer>
400067e4: 90 10 00 10 mov %l0, %o0
if ( !block_ptr )
400067e8: 80 a2 20 00 cmp %o0, 0
400067ec: 02 bf ff fa be 400067d4 <IMFS_memfile_write+0xbc>
<== NEVER TAKEN
400067f0: a4 24 80 13 sub %l2, %l3, %l2
400067f4: 80 a7 00 12 cmp %i4, %l2
400067f8: 18 80 00 37 bgu 400068d4 <IMFS_memfile_write+0x1bc>
400067fc: b0 10 00 1c mov %i4, %i0
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
40006800: d0 02 00 00 ld [ %o0 ], %o0
40006804: 92 10 00 1b mov %i3, %o1
40006808: 94 10 00 18 mov %i0, %o2
4000680c: 90 02 00 13 add %o0, %l3, %o0
40006810: 40 00 3b 82 call 40015618 <memcpy>
40006814: b6 06 c0 18 add %i3, %i0, %i3
block++;
40006818: b4 06 a0 01 inc %i2
4000681c: fa 04 60 1c ld [ %l1 + 0x1c ], %i5
my_length -= to_copy;
40006820: 10 bf ff d7 b 4000677c <IMFS_memfile_write+0x64>
40006824: b8 27 00 18 sub %i4, %i0, %i4
if ( my_length ) {
40006828: 80 a7 20 00 cmp %i4, 0
4000682c: 02 80 00 0c be 4000685c <IMFS_memfile_write+0x144>
40006830: 94 10 20 00 clr %o2
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40006834: 92 10 00 1a mov %i2, %o1
40006838: 7f ff fd b5 call 40005f0c <IMFS_memfile_get_block_pointer>
4000683c: 90 10 00 10 mov %l0, %o0
if ( !block_ptr )
40006840: 80 a2 20 00 cmp %o0, 0
40006844: 02 bf ff e4 be 400067d4 <IMFS_memfile_write+0xbc>
<== NEVER TAKEN
40006848: 94 10 00 1c mov %i4, %o2
memcpy( &(*block_ptr)[ 0 ], src, my_length );
4000684c: d0 02 00 00 ld [ %o0 ], %o0
40006850: 92 10 00 1b mov %i3, %o1
40006854: 40 00 3b 71 call 40015618 <memcpy>
40006858: b0 06 00 1c add %i0, %i4, %i0
_Timecounter_Getbintime( &now );
4000685c: 40 00 13 c1 call 4000b760 <_Timecounter_Getbintime>
40006860: 90 07 bf f0 add %fp, -16, %o0
return now.sec;
40006864: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_mtime = now;
40006868: c4 3c 20 28 std %g2, [ %l0 + 0x28 ]
jnode->stat_ctime = now;
4000686c: c4 3c 20 30 std %g2, [ %l0 + 0x30 ]
}
40006870: 81 c7 e0 08 ret
40006874: 81 e8 00 00 restore
bool zero_fill = start > memfile->File.size;
40006878: 80 a6 60 00 cmp %i1, 0
4000687c: 04 80 00 0b ble 400068a8 <IMFS_memfile_write+0x190>
<== ALWAYS TAKEN
40006880: 92 10 20 01 mov 1, %o1
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
40006884: 94 10 20 00 clr %o2
<== NOT EXECUTED
40006888: 92 0a 60 01 and %o1, 1, %o1
4000688c: 7f ff fe 49 call 400061b0 <IMFS_memfile_extend>
40006890: 90 10 00 10 mov %l0, %o0
if ( status )
40006894: b0 92 20 00 orcc %o0, 0, %i0
40006898: 02 bf ff a7 be 40006734 <IMFS_memfile_write+0x1c>
<== ALWAYS TAKEN
4000689c: 23 10 00 9b sethi %hi(0x40026c00), %l1
400068a0: 81 c7 e0 08 ret
400068a4: 81 e8 00 00 restore
bool zero_fill = start > memfile->File.size;
400068a8: 02 80 00 16 be 40006900 <IMFS_memfile_write+0x1e8>
<== ALWAYS TAKEN
400068ac: 80 a6 80 01 cmp %i2, %g1
400068b0: 92 10 20 00 clr %o1
<== NOT EXECUTED
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
400068b4: 94 10 20 00 clr %o2
<== NOT EXECUTED
400068b8: 92 0a 60 01 and %o1, 1, %o1
400068bc: 7f ff fe 3d call 400061b0 <IMFS_memfile_extend>
400068c0: 90 10 00 10 mov %l0, %o0
if ( status )
400068c4: b0 92 20 00 orcc %o0, 0, %i0
400068c8: 02 bf ff 9b be 40006734 <IMFS_memfile_write+0x1c>
400068cc: 23 10 00 9b sethi %hi(0x40026c00), %l1
400068d0: 30 bf ff f4 b,a 400068a0 <IMFS_memfile_write+0x188>
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
400068d4: d0 02 00 00 ld [ %o0 ], %o0
400068d8: b0 10 00 12 mov %l2, %i0
400068dc: 92 10 00 1b mov %i3, %o1
400068e0: 94 10 00 18 mov %i0, %o2
400068e4: 90 02 00 13 add %o0, %l3, %o0
400068e8: 40 00 3b 4c call 40015618 <memcpy>
400068ec: b6 06 c0 18 add %i3, %i0, %i3
block++;
400068f0: b4 06 a0 01 inc %i2
400068f4: fa 04 60 1c ld [ %l1 + 0x1c ], %i5
my_length -= to_copy;
400068f8: 10 bf ff a1 b 4000677c <IMFS_memfile_write+0x64>
400068fc: b8 27 00 18 sub %i4, %i0, %i4
bool zero_fill = start > memfile->File.size;
40006900: 18 bf ff e2 bgu 40006888 <IMFS_memfile_write+0x170>
40006904: 94 10 20 00 clr %o2
40006908: 10 bf ff ec b 400068b8 <IMFS_memfile_write+0x1a0>
4000690c: 92 10 20 00 clr %o1
4002319c <IMFS_mknod_control_device>:
4002319c: 40 02 31 b0 40 00 5b 14 40 00 6b 8c 40 00 6b 94 @.1.@.[.@.k.@.k.
400231ac: 00 00 00 48 ...H
40023140 <IMFS_mknod_control_dir_default>:
40023140: 40 02 31 54 40 00 58 60 40 00 58 78 40 00 6b 94 @.1T@.X`@.Xx@.k.
40023150: 00 00 00 50 ...P
4000ff9c <IMFS_mknod_control_dir_minimal>:
4000ff9c: 40 00 ff b0 40 00 2c 28 40 00 2c 40 40 00 3f 98 @...@.,(@.,@@.?.
4000ffac: 00 00 00 50 ...P
400231f0 <IMFS_mknod_control_enosys>:
400231f0: 40 02 37 d0 40 00 5b 48 40 00 6b 8c 40 00 6b 94 @.7.@.[H@.k.@.k.
40023200: 00 00 00 40 ...@
40023254 <IMFS_mknod_control_memfile>:
40023254: 40 02 32 68 40 00 5c 18 40 00 6b 8c 40 00 65 b4 @.2h@.\.@.k.@.e.
40023264: 00 00 00 58 ...X
40006a24 <IMFS_mount>:
#endif
#include <rtems/imfs.h>
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40006a24: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40006a28: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40006a2c: c4 00 60 08 ld [ %g1 + 8 ], %g2
return S_ISDIR( node->st_mode );
40006a30: 07 00 00 3c sethi %hi(0xf000), %g3
40006a34: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
40006a38: 82 08 40 03 and %g1, %g3, %g1
if ( IMFS_is_directory( node ) ) {
40006a3c: 07 00 00 10 sethi %hi(0x4000), %g3
40006a40: 80 a0 40 03 cmp %g1, %g3
40006a44: 12 80 00 0f bne 40006a80 <IMFS_mount+0x5c>
<== NEVER TAKEN
40006a48: 01 00 00 00 nop
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == NULL ) {
40006a4c: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
40006a50: 80 a0 60 00 cmp %g1, 0
40006a54: 12 80 00 05 bne 40006a68 <IMFS_mount+0x44>
<== NEVER TAKEN
40006a58: 01 00 00 00 nop
dir->mt_fs = mt_entry;
40006a5c: f0 20 a0 4c st %i0, [ %g2 + 0x4c ]
40006a60: 81 c7 e0 08 ret
40006a64: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = EBUSY;
40006a68: 40 00 39 18 call 40014ec8 <__errno>
<== NOT EXECUTED
40006a6c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006a70: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
40006a74: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006a78: 81 c7 e0 08 ret
<== NOT EXECUTED
40006a7c: 81 e8 00 00 restore
<== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40006a80: 40 00 39 12 call 40014ec8 <__errno>
<== NOT EXECUTED
40006a84: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006a88: 82 10 20 14 mov 0x14, %g1
<== NOT EXECUTED
40006a8c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
40006a90: 81 c7 e0 08 ret
<== NOT EXECUTED
40006a94: 81 e8 00 00 restore
<== NOT EXECUTED
40005878 <IMFS_node_remove_directory>:
{
return dir->mt_fs != NULL;
}
IMFS_jnode_t *IMFS_node_remove_directory( IMFS_jnode_t *node )
{
40005878: 9d e3 bf a0 save %sp, -96, %sp
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( !rtems_chain_is_empty( &dir->Entries ) ) {
4000587c: c4 06 20 40 ld [ %i0 + 0x40 ], %g2
return &the_chain->Tail.Node;
40005880: 82 06 20 44 add %i0, 0x44, %g1
40005884: 80 a0 80 01 cmp %g2, %g1
40005888: 12 80 00 0c bne 400058b8 <IMFS_node_remove_directory+0x40>
4000588c: 01 00 00 00 nop
errno = ENOTEMPTY;
dir = NULL;
} else if ( IMFS_is_mount_point( dir ) ) {
40005890: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
40005894: 80 a0 60 00 cmp %g1, 0
40005898: 02 80 00 0c be 400058c8 <IMFS_node_remove_directory+0x50> <== ALWAYS TAKEN
4000589c: 01 00 00 00 nop
errno = EBUSY;
400058a0: 40 00 3d 8a call 40014ec8 <__errno>
<== NOT EXECUTED
400058a4: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
400058a8: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
400058ac: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
dir = NULL;
}
return &dir->Node;
}
400058b0: 81 c7 e0 08 ret
<== NOT EXECUTED
400058b4: 81 e8 00 00 restore
<== NOT EXECUTED
errno = ENOTEMPTY;
400058b8: 40 00 3d 84 call 40014ec8 <__errno>
400058bc: b0 10 20 00 clr %i0
400058c0: 82 10 20 5a mov 0x5a, %g1
400058c4: c2 22 00 00 st %g1, [ %o0 ]
400058c8: 81 c7 e0 08 ret
400058cc: 81 e8 00 00 restore
40006e5c <IMFS_readlink>:
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40006e5c: 80 a2 a0 00 cmp %o2, 0
40006e60: 02 80 00 16 be 40006eb8 <IMFS_readlink+0x5c>
<== NEVER TAKEN
40006e64: c6 02 20 08 ld [ %o0 + 8 ], %g3
40006e68: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
40006e6c: c4 48 40 00 ldsb [ %g1 ], %g2
40006e70: 90 10 20 00 clr %o0
40006e74: 80 a0 a0 00 cmp %g2, 0
40006e78: 12 80 00 07 bne 40006e94 <IMFS_readlink+0x38>
<== ALWAYS TAKEN
40006e7c: c2 08 40 00 ldub [ %g1 ], %g1
40006e80: 30 80 00 0c b,a 40006eb0 <IMFS_readlink+0x54>
<== NOT EXECUTED
40006e84: c4 48 40 08 ldsb [ %g1 + %o0 ], %g2
40006e88: 80 a0 a0 00 cmp %g2, 0
40006e8c: 02 80 00 07 be 40006ea8 <IMFS_readlink+0x4c>
40006e90: c2 08 40 08 ldub [ %g1 + %o0 ], %g1
buf[i] = sym_link->name[i];
40006e94: c2 2a 40 08 stb %g1, [ %o1 + %o0 ]
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40006e98: 90 02 20 01 inc %o0
40006e9c: 80 a2 80 08 cmp %o2, %o0
40006ea0: 32 bf ff f9 bne,a 40006e84 <IMFS_readlink+0x28>
40006ea4: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
}
40006ea8: 81 c3 e0 08 retl
40006eac: 01 00 00 00 nop
40006eb0: 81 c3 e0 08 retl
<== NOT EXECUTED
40006eb4: 01 00 00 00 nop
<== NOT EXECUTED
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40006eb8: 81 c3 e0 08 retl
<== NOT EXECUTED
40006ebc: 90 10 20 00 clr %o0 ! 0 <PROM_START>
<== NOT EXECUTED
40006bc0 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
40006bc0: 9d e3 bf 90 save %sp, -112, %sp
IMFS_jnode_t *node = oldloc->node_access;
40006bc4: fa 06 60 08 ld [ %i1 + 8 ], %i5
/*
* FIXME: Due to insufficient checks we can create inaccessible nodes with
* this operation.
*/
if ( node->Parent == NULL ) {
40006bc8: c2 07 60 08 ld [ %i5 + 8 ], %g1
40006bcc: 80 a0 60 00 cmp %g1, 0
40006bd0: 02 80 00 36 be 40006ca8 <IMFS_rename+0xe8>
<== NEVER TAKEN
40006bd4: f4 06 a0 08 ld [ %i2 + 8 ], %i2
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( namelen >= IMFS_NAME_MAX ) {
40006bd8: 80 a7 20 fe cmp %i4, 0xfe
40006bdc: 18 80 00 27 bgu 40006c78 <IMFS_rename+0xb8>
40006be0: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
}
allocated_name = malloc( namelen );
40006be4: 40 00 03 53 call 40007930 <malloc>
40006be8: 90 10 00 1c mov %i4, %o0
if ( allocated_name == NULL ) {
40006bec: b2 92 20 00 orcc %o0, 0, %i1
40006bf0: 02 80 00 28 be 40006c90 <IMFS_rename+0xd0>
<== NEVER TAKEN
40006bf4: 94 10 00 1c mov %i4, %o2
rtems_set_errno_and_return_minus_one( ENOMEM );
}
memcpy( allocated_name, name, namelen );
40006bf8: 40 00 3a 88 call 40015618 <memcpy>
40006bfc: 92 10 00 1b mov %i3, %o1
if ( ( node->flags & IMFS_NODE_FLAG_NAME_ALLOCATED ) != 0 ) {
40006c00: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1
40006c04: 80 88 60 01 btst 1, %g1
40006c08: 12 80 00 18 bne 40006c68 <IMFS_rename+0xa8>
<== NEVER TAKEN
40006c0c: 01 00 00 00 nop
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
40006c10: c6 07 40 00 ld [ %i5 ], %g3
previous = the_node->previous;
40006c14: c4 07 60 04 ld [ %i5 + 4 ], %g2
free( RTEMS_DECONST( char *, node->name ) );
}
node->name = allocated_name;
40006c18: f2 27 60 0c st %i1, [ %i5 + 0xc ]
node->namelen = namelen;
node->flags |= IMFS_NODE_FLAG_NAME_ALLOCATED;
40006c1c: 82 10 60 01 or %g1, 1, %g1
node->namelen = namelen;
40006c20: f8 37 60 10 sth %i4, [ %i5 + 0x10 ]
return &the_chain->Tail.Node;
40006c24: 88 06 a0 44 add %i2, 0x44, %g4
node->flags |= IMFS_NODE_FLAG_NAME_ALLOCATED;
40006c28: c2 37 60 12 sth %g1, [ %i5 + 0x12 ]
_Timecounter_Getbintime( &now );
40006c2c: 90 07 bf f0 add %fp, -16, %o0
next->previous = previous;
40006c30: 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;
40006c34: b0 10 20 00 clr %i0
previous->next = next;
40006c38: 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;
40006c3c: c2 06 a0 48 ld [ %i2 + 0x48 ], %g1
entry_node->Parent = dir_node;
40006c40: f4 27 60 08 st %i2, [ %i5 + 8 ]
the_node->next = tail;
40006c44: c8 27 40 00 st %g4, [ %i5 ]
tail->previous = the_node;
40006c48: fa 26 a0 48 st %i5, [ %i2 + 0x48 ]
old_last->next = the_node;
40006c4c: fa 20 40 00 st %i5, [ %g1 ]
_Timecounter_Getbintime( &now );
40006c50: 40 00 12 c4 call 4000b760 <_Timecounter_Getbintime>
40006c54: c2 27 60 04 st %g1, [ %i5 + 4 ]
return now.sec;
40006c58: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_ctime = _IMFS_get_time();
40006c5c: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
}
40006c60: 81 c7 e0 08 ret
40006c64: 81 e8 00 00 restore
free( RTEMS_DECONST( char *, node->name ) );
40006c68: 40 00 01 46 call 40007180 <free>
<== NOT EXECUTED
40006c6c: d0 07 60 0c ld [ %i5 + 0xc ], %o0
<== NOT EXECUTED
40006c70: 10 bf ff e8 b 40006c10 <IMFS_rename+0x50>
<== NOT EXECUTED
40006c74: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
40006c78: 40 00 38 94 call 40014ec8 <__errno>
40006c7c: b0 10 3f ff mov -1, %i0
40006c80: 82 10 20 5b mov 0x5b, %g1
40006c84: c2 22 00 00 st %g1, [ %o0 ]
40006c88: 81 c7 e0 08 ret
40006c8c: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( ENOMEM );
40006c90: 40 00 38 8e call 40014ec8 <__errno>
<== NOT EXECUTED
40006c94: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006c98: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40006c9c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006ca0: 81 c7 e0 08 ret
<== NOT EXECUTED
40006ca4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
40006ca8: 40 00 38 88 call 40014ec8 <__errno>
<== NOT EXECUTED
40006cac: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006cb0: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40006cb4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006cb8: 81 c7 e0 08 ret
<== NOT EXECUTED
40006cbc: 81 e8 00 00 restore
<== NOT EXECUTED
40006cc0 <IMFS_rmnod>:
int IMFS_rmnod(
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
40006cc0: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = loc->node_access;
40006cc4: d0 06 60 08 ld [ %i1 + 8 ], %o0
node = (*node->control->node_remove)( node );
40006cc8: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
40006ccc: c2 00 60 08 ld [ %g1 + 8 ], %g1
40006cd0: 9f c0 40 00 call %g1
40006cd4: 01 00 00 00 nop
if ( node != NULL ) {
40006cd8: 80 a2 20 00 cmp %o0, 0
40006cdc: 22 80 00 11 be,a 40006d20 <IMFS_rmnod+0x60>
40006ce0: b0 10 3f ff mov -1, %i0
--node->reference_count;
40006ce4: c4 12 20 18 lduh [ %o0 + 0x18 ], %g2
--node->st_nlink;
40006ce8: c2 12 20 1a lduh [ %o0 + 0x1a ], %g1
40006cec: 82 00 7f ff add %g1, -1, %g1
--node->reference_count;
40006cf0: 84 00 bf ff add %g2, -1, %g2
--node->st_nlink;
40006cf4: c2 32 20 1a sth %g1, [ %o0 + 0x1a ]
--node->reference_count;
40006cf8: c4 32 20 18 sth %g2, [ %o0 + 0x18 ]
if ( node->Parent != NULL ) {
40006cfc: c2 02 20 08 ld [ %o0 + 8 ], %g1
40006d00: 80 a0 60 00 cmp %g1, 0
40006d04: 02 80 00 07 be 40006d20 <IMFS_rmnod+0x60>
40006d08: b0 10 20 00 clr %i0
node->Parent = NULL;
40006d0c: c0 22 20 08 clr [ %o0 + 8 ]
next = the_node->next;
40006d10: c4 02 00 00 ld [ %o0 ], %g2
previous = the_node->previous;
40006d14: c2 02 20 04 ld [ %o0 + 4 ], %g1
next->previous = previous;
40006d18: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40006d1c: c4 20 40 00 st %g2, [ %g1 ]
40006d20: 81 c7 e0 08 ret
40006d24: 81 e8 00 00 restore
} else {
rv = -1;
}
return rv;
}
40006d28: 81 c7 e0 08 ret
<== NOT EXECUTED
40006d2c: 81 e8 00 00 restore
<== NOT EXECUTED
40006df8 <IMFS_symlink>:
{
40006df8: 9d e3 bf 98 save %sp, -104, %sp
sizeof( IMFS_sym_link_t ) + strlen( target ) + 1,
40006dfc: 40 00 3c 22 call 40015e84 <strlen>
40006e00: 90 10 00 1b mov %i3, %o0
new_node = IMFS_create_node(
40006e04: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
40006e08: 94 02 20 49 add %o0, 0x49, %o2
40006e0c: 98 10 00 1a mov %i2, %o4
40006e10: 90 10 00 18 mov %i0, %o0
40006e14: 1b 00 00 28 sethi %hi(0xa000), %o5
40006e18: 96 10 00 19 mov %i1, %o3
40006e1c: 9a 13 61 ff or %o5, 0x1ff, %o5
40006e20: 13 10 00 8c sethi %hi(0x40023000), %o1
return 0;
40006e24: b0 10 20 00 clr %i0
new_node = IMFS_create_node(
40006e28: 40 00 30 9a call 40013090 <IMFS_create_node>
40006e2c: 92 12 62 e8 or %o1, 0x2e8, %o1
if ( new_node == NULL ) {
40006e30: 80 a2 20 00 cmp %o0, 0
40006e34: 02 80 00 04 be 40006e44 <IMFS_symlink+0x4c>
<== NEVER TAKEN
40006e38: 01 00 00 00 nop
}
40006e3c: 81 c7 e0 08 ret
40006e40: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( ENOMEM );
40006e44: 40 00 38 21 call 40014ec8 <__errno>
<== NOT EXECUTED
40006e48: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006e4c: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40006e50: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40006e54: 81 c7 e0 08 ret
<== NOT EXECUTED
40006e58: 81 e8 00 00 restore
<== NOT EXECUTED
40006ec0 <IMFS_unmount>:
#endif
#include <rtems/imfs.h>
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40006ec0: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40006ec4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40006ec8: c4 00 60 08 ld [ %g1 + 8 ], %g2
return S_ISDIR( node->st_mode );
40006ecc: 07 00 00 3c sethi %hi(0xf000), %g3
40006ed0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
40006ed4: 82 08 40 03 and %g1, %g3, %g1
if ( IMFS_is_directory( node ) ) {
40006ed8: 07 00 00 10 sethi %hi(0x4000), %g3
40006edc: 80 a0 40 03 cmp %g1, %g3
40006ee0: 12 80 00 0f bne 40006f1c <IMFS_unmount+0x5c>
<== NEVER TAKEN
40006ee4: 01 00 00 00 nop
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == mt_entry ) {
40006ee8: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
40006eec: 80 a0 40 18 cmp %g1, %i0
40006ef0: 12 80 00 05 bne 40006f04 <IMFS_unmount+0x44>
<== NEVER TAKEN
40006ef4: 01 00 00 00 nop
dir->mt_fs = NULL;
40006ef8: c0 20 a0 4c clr [ %g2 + 0x4c ]
40006efc: 81 c7 e0 08 ret
40006f00: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = EINVAL;
40006f04: 40 00 37 f1 call 40014ec8 <__errno>
<== NOT EXECUTED
40006f08: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006f0c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40006f10: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006f14: 81 c7 e0 08 ret
<== NOT EXECUTED
40006f18: 81 e8 00 00 restore
<== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40006f1c: 40 00 37 eb call 40014ec8 <__errno>
<== NOT EXECUTED
40006f20: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006f24: 82 10 20 14 mov 0x14, %g1
<== NOT EXECUTED
40006f28: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
40006f2c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006f30: 81 e8 00 00 restore
<== NOT EXECUTED
40013088 <device_ftruncate>:
rtems_libio_t *iop,
off_t length
)
{
return 0;
}
40013088: 81 c3 e0 08 retl
<== NOT EXECUTED
4001308c: 90 10 20 00 clr %o0
<== NOT EXECUTED