400145a0 <IMFS_LIMITS_AND_OPTIONS>:
400145a0: 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00 ff ................
400145b0: 00 00 00 ff 00 00 00 02 00 00 00 01 00 00 00 02 ................
400145c0: 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00 06 ................
400145d0: 28 64 65 66 61 75 6c 74 29 00 00 00 (default)...
400035a0 <IMFS_chown>:
int IMFS_chown(
const rtems_filesystem_location_info_t *loc,
uid_t owner,
gid_t group
)
{
400035a0: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
IMFS_jnode_t *jnode;
jnode = (IMFS_jnode_t *) loc->node_access;
400035a4: fa 06 20 08 ld [ %i0 + 8 ], %i5
<== NOT EXECUTED
jnode->st_uid = owner;
400035a8: f2 37 60 1c sth %i1, [ %i5 + 0x1c ]
<== NOT EXECUTED
static inline time_t _IMFS_get_time( void )
{
struct bintime now;
/* Use most efficient way to get the time in seconds (CLOCK_REALTIME) */
_Timecounter_Getbintime( &now );
400035ac: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
jnode->st_gid = group;
400035b0: f4 37 60 1e sth %i2, [ %i5 + 0x1e ]
<== NOT EXECUTED
400035b4: 40 00 16 18 call 40008e14 <_Timecounter_Getbintime>
<== NOT EXECUTED
400035b8: b0 10 20 00 clr %i0
<== NOT EXECUTED
return now.sec;
400035bc: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_mtime = _IMFS_get_time();
}
static inline void IMFS_update_ctime( IMFS_jnode_t *jnode )
{
jnode->stat_ctime = _IMFS_get_time();
400035c0: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
<== NOT EXECUTED
IMFS_update_ctime( jnode );
return 0;
}
400035c4: 81 c7 e0 08 ret
<== NOT EXECUTED
400035c8: 81 e8 00 00 restore
<== NOT EXECUTED
4001053c <IMFS_create_node>:
const char *name,
size_t namelen,
mode_t mode,
void *arg
)
{
4001053c: 9d e3 bf a0 save %sp, -96, %sp
IMFS_jnode_t *allocated_node;
IMFS_jnode_t *node;
allocated_node = calloc( 1, node_size + namelen );
40010540: 90 10 20 01 mov 1, %o0
40010544: 7f ff d2 06 call 40004d5c <calloc>
40010548: 92 06 80 1c add %i2, %i4, %o1
if ( allocated_node == NULL ) {
4001054c: a0 92 20 00 orcc %o0, 0, %l0
40010550: 02 80 00 1c be 400105c0 <IMFS_create_node+0x84>
40010554: da 07 a0 5c ld [ %fp + 0x5c ], %o5
errno = ENOMEM;
return NULL;
}
node = IMFS_initialize_node(
40010558: 98 10 00 1d mov %i5, %o4
4001055c: 96 10 00 1c mov %i4, %o3
40010560: 94 04 00 1a add %l0, %i2, %o2
40010564: 7f ff d0 c9 call 40004888 <IMFS_initialize_node>
40010568: 92 10 00 19 mov %i1, %o1
(char *) allocated_node + node_size,
namelen,
mode,
arg
);
if ( node != NULL ) {
4001056c: ba 92 20 00 orcc %o0, 0, %i5
40010570: 02 80 00 0f be 400105ac <IMFS_create_node+0x70>
<== NEVER TAKEN
40010574: 94 10 00 1c mov %i4, %o2
IMFS_jnode_t *parent = parentloc->node_access;
memcpy( RTEMS_DECONST( char *, node->name ), name, namelen );
40010578: d0 07 60 0c ld [ %i5 + 0xc ], %o0
IMFS_jnode_t *parent = parentloc->node_access;
4001057c: f4 06 20 08 ld [ %i0 + 8 ], %i2
memcpy( RTEMS_DECONST( char *, node->name ), name, namelen );
40010580: 40 00 07 fa call 40012568 <memcpy>
40010584: 92 10 00 1b mov %i3, %o1
old_last = tail->previous;
40010588: c2 06 a0 48 ld [ %i2 + 0x48 ], %g1
return &the_chain->Tail.Node;
4001058c: 84 06 a0 44 add %i2, 0x44, %g2
entry_node->Parent = dir_node;
40010590: f4 27 60 08 st %i2, [ %i5 + 8 ]
the_node->next = tail;
40010594: c4 27 40 00 st %g2, [ %i5 ]
tail->previous = the_node;
40010598: fa 26 a0 48 st %i5, [ %i2 + 0x48 ]
old_last->next = the_node;
4001059c: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
400105a0: c2 27 60 04 st %g1, [ %i5 + 4 ]
} else {
free( allocated_node );
}
return node;
}
400105a4: 81 c7 e0 08 ret
400105a8: 91 e8 00 1d restore %g0, %i5, %o0
free( allocated_node );
400105ac: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
400105b0: 7f ff d2 6c call 40004f60 <free>
<== NOT EXECUTED
400105b4: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
400105b8: 81 c7 e0 08 ret
<== NOT EXECUTED
400105bc: 81 e8 00 00 restore
<== NOT EXECUTED
errno = ENOMEM;
400105c0: 40 00 07 ad call 40012474 <__errno>
400105c4: ba 10 20 00 clr %i5
400105c8: 82 10 20 0c mov 0xc, %g1
return NULL;
400105cc: 10 bf ff f6 b 400105a4 <IMFS_create_node+0x68>
400105d0: c2 22 00 00 st %g1, [ %o0 ]
40003a10 <IMFS_fchmod>:
int IMFS_fchmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
40003a10: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
IMFS_jnode_t *jnode;
jnode = loc->node_access;
40003a14: fa 06 20 08 ld [ %i0 + 8 ], %i5
<== NOT EXECUTED
jnode->st_mode = mode;
40003a18: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
40003a1c: 40 00 14 fe call 40008e14 <_Timecounter_Getbintime>
<== NOT EXECUTED
40003a20: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
return now.sec;
40003a24: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_ctime = _IMFS_get_time();
40003a28: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
<== NOT EXECUTED
IMFS_update_ctime( jnode );
return 0;
}
40003a2c: 81 c7 e0 08 ret
<== NOT EXECUTED
40003a30: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
400285c8 <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
)
{
400285c8: 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;
400285cc: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
<== NOT EXECUTED
400285d0: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
400285d4: f6 00 40 00 ld [ %g1 ], %i3
<== NOT EXECUTED
400285d8: f8 00 60 04 ld [ %g1 + 4 ], %i4
<== NOT EXECUTED
400285dc: c8 00 60 0c ld [ %g1 + 0xc ], %g4
<== NOT EXECUTED
400285e0: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
<== NOT EXECUTED
400285e4: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
<== NOT EXECUTED
jnode = (IMFS_jnode_t *)loc.node_access;
400285e8: ba 10 00 02 mov %g2, %i5
<== NOT EXECUTED
loc = temp_mt_entry->mt_fs_root->location;
400285ec: c4 27 bf f0 st %g2, [ %fp + -16 ]
<== NOT EXECUTED
return S_ISDIR( node->st_mode );
400285f0: 35 00 00 3c sethi %hi(0xf000), %i2
<== NOT EXECUTED
400285f4: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
400285f8: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
<== NOT EXECUTED
loc->handlers = node->control->handlers;
400285fc: c4 07 60 38 ld [ %i5 + 0x38 ], %g2
<== NOT EXECUTED
40028600: c4 00 80 00 ld [ %g2 ], %g2
<== NOT EXECUTED
40028604: c6 27 bf f8 st %g3, [ %fp + -8 ]
<== NOT EXECUTED
return S_ISDIR( node->st_mode );
40028608: 82 08 40 1a and %g1, %i2, %g1
<== NOT EXECUTED
4002860c: f6 27 bf e8 st %i3, [ %fp + -24 ]
<== NOT EXECUTED
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
40028610: 37 00 00 10 sethi %hi(0x4000), %i3
<== NOT EXECUTED
loc = temp_mt_entry->mt_fs_root->location;
40028614: f8 27 bf ec st %i4, [ %fp + -20 ]
<== NOT EXECUTED
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
40028618: 80 a0 40 1b cmp %g1, %i3
<== NOT EXECUTED
next = jnode->Parent;
4002861c: f8 07 60 08 ld [ %i5 + 8 ], %i4
<== NOT EXECUTED
loc = temp_mt_entry->mt_fs_root->location;
40028620: c8 27 bf f4 st %g4, [ %fp + -12 ]
<== NOT EXECUTED
loc.node_access = (void *)jnode;
40028624: fa 27 bf f0 st %i5, [ %fp + -16 ]
<== NOT EXECUTED
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
40028628: 12 80 00 14 bne 40028678 <IMFS_fsunmount+0xb0>
<== NOT EXECUTED
4002862c: c4 27 bf f8 st %g2, [ %fp + -8 ]
<== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40028630: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
<== NOT EXECUTED
return &the_chain->Tail.Node;
40028634: 82 07 60 44 add %i5, 0x44, %g1
<== NOT EXECUTED
40028638: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
4002863c: 02 80 00 10 be 4002867c <IMFS_fsunmount+0xb4>
<== NOT EXECUTED
40028640: 92 07 bf e8 add %fp, -24, %o1
<== NOT EXECUTED
if ( IMFS_is_directory( jnode ) ) {
if ( jnode_has_children( jnode ) )
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
40028644: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40028648: 02 80 00 23 be 400286d4 <IMFS_fsunmount+0x10c>
<== NOT EXECUTED
4002864c: b8 10 00 02 mov %g2, %i4
<== NOT EXECUTED
40028650: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
<== NOT EXECUTED
40028654: ba 10 00 1c mov %i4, %i5
<== NOT EXECUTED
loc->handlers = node->control->handlers;
40028658: c4 07 60 38 ld [ %i5 + 0x38 ], %g2
<== NOT EXECUTED
4002865c: c4 00 80 00 ld [ %g2 ], %g2
<== NOT EXECUTED
next = jnode->Parent;
40028660: f8 07 60 08 ld [ %i5 + 8 ], %i4
<== NOT EXECUTED
loc.node_access = (void *)jnode;
40028664: fa 27 bf f0 st %i5, [ %fp + -16 ]
<== NOT EXECUTED
return S_ISDIR( node->st_mode );
40028668: 82 08 40 1a and %g1, %i2, %g1
<== NOT EXECUTED
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4002866c: 80 a0 40 1b cmp %g1, %i3
<== NOT EXECUTED
40028670: 02 bf ff f0 be 40028630 <IMFS_fsunmount+0x68>
<== NOT EXECUTED
40028674: c4 27 bf f8 st %g2, [ %fp + -8 ]
<== NOT EXECUTED
result = IMFS_rmnod( NULL, &loc );
40028678: 92 07 bf e8 add %fp, -24, %o1
<== NOT EXECUTED
4002867c: 7f ff 95 90 call 4000dcbc <IMFS_rmnod>
<== NOT EXECUTED
40028680: 90 10 20 00 clr %o0
<== NOT EXECUTED
if ( result != 0 )
40028684: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40028688: 12 80 00 15 bne 400286dc <IMFS_fsunmount+0x114>
<== NOT EXECUTED
4002868c: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
<== NOT EXECUTED
IMFS_node_destroy( jnode );
40028690: 7f ff 95 28 call 4000db30 <IMFS_node_destroy>
<== NOT EXECUTED
40028694: 90 10 00 1d mov %i5, %o0
<== NOT EXECUTED
if ( jnode != NULL ) {
40028698: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
4002869c: 02 80 00 0e be 400286d4 <IMFS_fsunmount+0x10c>
<== NOT EXECUTED
400286a0: 01 00 00 00 nop
<== NOT EXECUTED
400286a4: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
<== NOT EXECUTED
400286a8: 84 08 40 1a and %g1, %i2, %g2
<== NOT EXECUTED
if ( IMFS_is_directory( jnode ) ) {
400286ac: 80 a0 80 1b cmp %g2, %i3
<== NOT EXECUTED
400286b0: 32 bf ff ea bne,a 40028658 <IMFS_fsunmount+0x90>
<== NOT EXECUTED
400286b4: ba 10 00 1c mov %i4, %i5
<== NOT EXECUTED
400286b8: c4 07 20 40 ld [ %i4 + 0x40 ], %g2
<== NOT EXECUTED
if ( jnode_has_children( jnode ) )
400286bc: 86 07 20 44 add %i4, 0x44, %g3
<== NOT EXECUTED
400286c0: 80 a0 80 03 cmp %g2, %g3
<== NOT EXECUTED
400286c4: 12 bf ff e1 bne 40028648 <IMFS_fsunmount+0x80>
<== NOT EXECUTED
400286c8: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
} while (jnode != NULL);
400286cc: 10 bf ff e3 b 40028658 <IMFS_fsunmount+0x90>
<== NOT EXECUTED
400286d0: ba 10 00 1c mov %i4, %i5
<== NOT EXECUTED
}
400286d4: 81 c7 e0 08 ret
<== NOT EXECUTED
400286d8: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_fatal_error_occurred( 0xdeadbeef );
400286dc: 7f ff e3 07 call 400212f8 <rtems_fatal_error_occurred>
<== NOT EXECUTED
400286e0: 90 12 22 ef or %o0, 0x2ef, %o0
<== NOT EXECUTED
400286e4: 01 00 00 00 nop
<== NOT EXECUTED
4000c8d8 <IMFS_initialize>:
int IMFS_initialize(
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
4000c8d8: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
IMFS_fs_info_t *fs_info = calloc( 1, sizeof( *fs_info ) );
4000c8dc: 92 10 20 58 mov 0x58, %o1
<== NOT EXECUTED
4000c8e0: 40 00 08 23 call 4000e96c <calloc>
<== NOT EXECUTED
4000c8e4: 90 10 20 01 mov 1, %o0
<== NOT EXECUTED
IMFS_mount_data mount_data = {
4000c8e8: 03 10 01 8d sethi %hi(0x40063400), %g1
<== NOT EXECUTED
4000c8ec: 82 10 61 7c or %g1, 0x17c, %g1 ! 4006357c <IMFS_ops>
<== NOT EXECUTED
4000c8f0: d0 27 bf f4 st %o0, [ %fp + -12 ]
<== NOT EXECUTED
.fs_info = fs_info,
.ops = &IMFS_ops,
.mknod_controls = &IMFS_default_mknod_controls
};
if ( fs_info == NULL ) {
4000c8f4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
IMFS_mount_data mount_data = {
4000c8f8: c2 27 bf f8 st %g1, [ %fp + -8 ]
<== NOT EXECUTED
4000c8fc: 03 10 01 8d sethi %hi(0x40063400), %g1
<== NOT EXECUTED
4000c900: 82 10 61 6c or %g1, 0x16c, %g1 ! 4006356c <IMFS_default_mknod_controls>
<== NOT EXECUTED
if ( fs_info == NULL ) {
4000c904: 02 80 00 07 be 4000c920 <IMFS_initialize+0x48>
<== NOT EXECUTED
4000c908: c2 27 bf fc st %g1, [ %fp + -4 ]
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
return IMFS_initialize_support( mt_entry, &mount_data );
4000c90c: 92 07 bf f4 add %fp, -12, %o1
<== NOT EXECUTED
4000c910: 40 00 00 11 call 4000c954 <IMFS_initialize_support>
<== NOT EXECUTED
4000c914: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
4000c918: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c91c: 91 e8 00 08 restore %g0, %o0, %o0
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4000c920: 40 00 d6 1d call 40042194 <__errno>
<== NOT EXECUTED
4000c924: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000c928: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
4000c92c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000c930: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c934: 81 e8 00 00 restore
<== NOT EXECUTED
40004888 <IMFS_initialize_node>:
const char *name,
size_t namelen,
mode_t mode,
void *arg
)
{
40004888: 9d e3 bf 90 save %sp, -112, %sp
struct timeval tv;
if ( namelen > IMFS_NAME_MAX ) {
4000488c: 80 a6 e0 ff cmp %i3, 0xff
40004890: 18 80 00 19 bgu 400048f4 <IMFS_initialize_node+0x6c>
<== NEVER TAKEN
40004894: 92 10 20 00 clr %o1
errno = ENAMETOOLONG;
return NULL;
}
gettimeofday( &tv, 0 );
40004898: 40 00 01 e0 call 40005018 <gettimeofday>
4000489c: 90 07 bf f0 add %fp, -16, %o0
/*
* Fill in the basic information
*/
node->name = name;
node->namelen = namelen;
node->reference_count = 1;
400048a0: 03 00 00 40 sethi %hi(0x10000), %g1
node->name = name;
400048a4: f4 26 20 0c st %i2, [ %i0 + 0xc ]
node->reference_count = 1;
400048a8: 82 10 60 01 or %g1, 1, %g1
node->namelen = namelen;
400048ac: f6 36 20 10 sth %i3, [ %i0 + 0x10 ]
node->reference_count = 1;
400048b0: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
node->st_nlink = 1;
node->control = node_control;
400048b4: 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();
400048b8: 40 00 01 d2 call 40005000 <geteuid>
400048bc: f8 26 20 14 st %i4, [ %i0 + 0x14 ]
node->st_gid = getegid();
400048c0: 40 00 01 ca call 40004fe8 <getegid>
400048c4: d0 36 20 1c sth %o0, [ %i0 + 0x1c ]
/*
* Now set all the times.
*/
node->stat_atime = (time_t) tv.tv_sec;
400048c8: c4 1f bf f0 ldd [ %fp + -16 ], %g2
node->st_gid = getegid();
400048cc: 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 );
400048d0: 92 10 00 1d mov %i5, %o1
node->stat_atime = (time_t) tv.tv_sec;
400048d4: c4 3e 20 20 std %g2, [ %i0 + 0x20 ]
node->stat_mtime = (time_t) tv.tv_sec;
400048d8: c4 3e 20 28 std %g2, [ %i0 + 0x28 ]
node->stat_ctime = (time_t) tv.tv_sec;
400048dc: c4 3e 20 30 std %g2, [ %i0 + 0x30 ]
return (*node_control->node_initialize)( node, arg );
400048e0: c2 06 60 04 ld [ %i1 + 4 ], %g1
400048e4: 9f c0 40 00 call %g1
400048e8: 90 10 00 18 mov %i0, %o0
}
400048ec: 81 c7 e0 08 ret
400048f0: 91 e8 00 08 restore %g0, %o0, %o0
errno = ENAMETOOLONG;
400048f4: 40 00 36 e0 call 40012474 <__errno>
<== NOT EXECUTED
400048f8: b0 10 20 00 clr %i0
<== NOT EXECUTED
400048fc: 82 10 20 5b mov 0x5b, %g1
<== NOT EXECUTED
40004900: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return NULL;
40004904: 81 c7 e0 08 ret
<== NOT EXECUTED
40004908: 81 e8 00 00 restore
<== NOT EXECUTED
40003a84 <IMFS_initialize_support>:
{
40003a84: 9d e3 bf a0 save %sp, -96, %sp
IMFS_fs_info_t *fs_info = mount_data->fs_info;
40003a88: fa 06 40 00 ld [ %i1 ], %i5
fs_info->mknod_controls = mount_data->mknod_controls;
40003a8c: c2 06 60 08 ld [ %i1 + 8 ], %g1
40003a90: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
root_node = IMFS_initialize_node(
40003a94: 9a 10 20 00 clr %o5
40003a98: d2 00 40 00 ld [ %g1 ], %o1
40003a9c: 96 10 20 00 clr %o3
40003aa0: 19 00 00 10 sethi %hi(0x4000), %o4
40003aa4: 90 10 00 1d mov %i5, %o0
40003aa8: 98 13 21 ed or %o4, 0x1ed, %o4
40003aac: 15 10 00 4f sethi %hi(0x40013c00), %o2
40003ab0: 40 00 03 76 call 40004888 <IMFS_initialize_node>
40003ab4: 94 12 a3 58 or %o2, 0x358, %o2 ! 40013f58 <rtems_test_name+0xf8>
mt_entry->ops = mount_data->ops;
40003ab8: c2 06 60 04 ld [ %i1 + 4 ], %g1
loc->handlers = node->control->handlers;
40003abc: c4 02 20 38 ld [ %o0 + 0x38 ], %g2
40003ac0: c2 26 20 0c st %g1, [ %i0 + 0xc ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
40003ac4: 03 10 00 51 sethi %hi(0x40014400), %g1
40003ac8: 82 10 61 a0 or %g1, 0x1a0, %g1 ! 400145a0 <IMFS_LIMITS_AND_OPTIONS>
mt_entry->fs_info = fs_info;
40003acc: fa 26 20 08 st %i5, [ %i0 + 8 ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
40003ad0: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
40003ad4: c4 00 80 00 ld [ %g2 ], %g2
mt_entry->mt_fs_root->location.node_access = root_node;
40003ad8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40003adc: d0 20 60 08 st %o0, [ %g1 + 8 ]
40003ae0: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
IMFS_determine_bytes_per_block(
40003ae4: 03 10 00 56 sethi %hi(0x40015800), %g1
40003ae8: c6 00 60 90 ld [ %g1 + 0x90 ], %g3 ! 40015890 <imfs_rq_memfile_bytes_per_block>
if (bit_mask == requested_bytes_per_block) {
40003aec: 80 a0 e0 10 cmp %g3, 0x10
40003af0: 02 80 00 0e be 40003b28 <IMFS_initialize_support+0xa4> <== NEVER TAKEN
40003af4: 80 a0 e0 0f cmp %g3, 0xf
if(bit_mask > requested_bytes_per_block)
40003af8: 04 80 00 0b ble 40003b24 <IMFS_initialize_support+0xa0> <== NEVER TAKEN
40003afc: 82 10 20 20 mov 0x20, %g1
40003b00: 84 10 20 05 mov 5, %g2
if (bit_mask == requested_bytes_per_block) {
40003b04: 80 a0 c0 01 cmp %g3, %g1
40003b08: 22 80 00 09 be,a 40003b2c <IMFS_initialize_support+0xa8>
40003b0c: 03 10 00 5c sethi %hi(0x40017000), %g1
if(bit_mask > requested_bytes_per_block)
40003b10: 26 80 00 06 bl,a 40003b28 <IMFS_initialize_support+0xa4> <== NEVER TAKEN
40003b14: 86 10 20 80 mov 0x80, %g3
<== NOT EXECUTED
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
40003b18: 84 80 bf ff addcc %g2, -1, %g2
40003b1c: 12 bf ff fa bne 40003b04 <IMFS_initialize_support+0x80> <== ALWAYS TAKEN
40003b20: 83 28 60 01 sll %g1, 1, %g1
: default_bytes_per_block);
40003b24: 86 10 20 80 mov 0x80, %g3
<== NOT EXECUTED
*dest_bytes_per_block = ((is_valid)
40003b28: 03 10 00 5c sethi %hi(0x40017000), %g1
<== NOT EXECUTED
40003b2c: c6 20 60 a0 st %g3, [ %g1 + 0xa0 ] ! 400170a0 <imfs_memfile_bytes_per_block>
}
40003b30: 81 c7 e0 08 ret
40003b34: 91 e8 20 00 restore %g0, 0, %o0
40003c24 <IMFS_link>:
{
40003c24: 9d e3 bf 88 save %sp, -120, %sp
<== NOT EXECUTED
target = targetloc->node_access;
40003c28: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
if ( target->st_nlink >= LINK_MAX )
40003c2c: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
<== NOT EXECUTED
40003c30: 80 a0 60 07 cmp %g1, 7
<== NOT EXECUTED
40003c34: 18 80 00 19 bgu 40003c98 <IMFS_link+0x74>
<== NOT EXECUTED
40003c38: 9a 10 21 ff mov 0x1ff, %o5
<== NOT EXECUTED
new_node = IMFS_create_node(
40003c3c: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
<== NOT EXECUTED
40003c40: 98 10 00 1b mov %i3, %o4
<== NOT EXECUTED
40003c44: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
40003c48: 94 10 20 48 mov 0x48, %o2
<== NOT EXECUTED
40003c4c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40003c50: 13 10 00 50 sethi %hi(0x40014000), %o1
<== NOT EXECUTED
40003c54: 40 00 32 3a call 4001053c <IMFS_create_node>
<== NOT EXECUTED
40003c58: 92 12 60 70 or %o1, 0x70, %o1 ! 40014070 <IMFS_node_control_hard_link>
<== NOT EXECUTED
if ( !new_node )
40003c5c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40003c60: 02 80 00 14 be 40003cb0 <IMFS_link+0x8c>
<== NOT EXECUTED
40003c64: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
target->reference_count++;
40003c68: c4 17 60 18 lduh [ %i5 + 0x18 ], %g2
<== NOT EXECUTED
target->st_nlink++;
40003c6c: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
<== NOT EXECUTED
target->reference_count++;
40003c70: 84 00 a0 01 inc %g2
<== NOT EXECUTED
target->st_nlink++;
40003c74: 82 00 60 01 inc %g1
<== NOT EXECUTED
target->reference_count++;
40003c78: c4 37 60 18 sth %g2, [ %i5 + 0x18 ]
<== NOT EXECUTED
target->st_nlink++;
40003c7c: c2 37 60 1a sth %g1, [ %i5 + 0x1a ]
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
40003c80: 40 00 14 65 call 40008e14 <_Timecounter_Getbintime>
<== NOT EXECUTED
40003c84: b0 10 20 00 clr %i0
<== NOT EXECUTED
return now.sec;
40003c88: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_ctime = _IMFS_get_time();
40003c8c: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
<== NOT EXECUTED
}
40003c90: 81 c7 e0 08 ret
<== NOT EXECUTED
40003c94: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EMLINK );
40003c98: 40 00 39 f7 call 40012474 <__errno>
<== NOT EXECUTED
40003c9c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40003ca0: 82 10 20 1f mov 0x1f, %g1
<== NOT EXECUTED
40003ca4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40003ca8: 81 c7 e0 08 ret
<== NOT EXECUTED
40003cac: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
40003cb0: 40 00 39 f1 call 40012474 <__errno>
<== NOT EXECUTED
40003cb4: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40003cb8: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40003cbc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40003cc0: 81 c7 e0 08 ret
<== NOT EXECUTED
40003cc4: 81 e8 00 00 restore
<== NOT EXECUTED
400105d4 <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
400105d4: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
400105d8: 7f ff d5 d6 call 40005d30 <rtems_current_user_env_get>
400105dc: 01 00 00 00 nop
400105e0: da 02 20 08 ld [ %o0 + 8 ], %o5
400105e4: b2 2e 40 0d andn %i1, %o5, %i1
switch (mode & S_IFMT) {
400105e8: 03 00 00 3c sethi %hi(0xf000), %g1
400105ec: 05 00 00 18 sethi %hi(0x6000), %g2
400105f0: 82 0e 40 01 and %i1, %g1, %g1
400105f4: 80 a0 40 02 cmp %g1, %g2
400105f8: 02 80 00 0c be 40010628 <IMFS_make_generic_node+0x54>
400105fc: 94 10 20 78 mov 0x78, %o2
40010600: 08 80 00 1d bleu 40010674 <IMFS_make_generic_node+0xa0> <== ALWAYS TAKEN
40010604: 05 00 00 04 sethi %hi(0x1000), %g2
40010608: 05 00 00 20 sethi %hi(0x8000), %g2
<== NOT EXECUTED
4001060c: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40010610: 02 80 00 06 be 40010628 <IMFS_make_generic_node+0x54>
<== NOT EXECUTED
40010614: 05 00 00 30 sethi %hi(0xc000), %g2
<== NOT EXECUTED
40010618: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4001061c: 12 80 00 1c bne 4001068c <IMFS_make_generic_node+0xb8>
<== NOT EXECUTED
40010620: 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 =
40010624: 94 10 20 78 mov 0x78, %o2 ! 78 <_TLS_Alignment+0x77>
<== NOT EXECUTED
40010628: 92 10 00 18 mov %i0, %o1
4001062c: 7f ff d7 b5 call 40006500 <rtems_filesystem_eval_path_start>
40010630: 90 07 bf c8 add %fp, -56, %o0
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
40010634: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40010638: c2 00 60 0c ld [ %g1 + 0xc ], %g1
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
4001063c: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
40010640: 03 10 00 12 sethi %hi(0x40004800), %g1
40010644: 82 10 61 0c or %g1, 0x10c, %g1 ! 4000490c <IMFS_node_clone>
40010648: 80 a0 80 01 cmp %g2, %g1
4001064c: 02 80 00 16 be 400106a4 <IMFS_make_generic_node+0xd0>
40010650: ba 10 00 08 mov %o0, %i5
IMFS_mtime_ctime_update( parent );
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
40010654: 92 10 20 86 mov 0x86, %o1
40010658: 90 07 bf c8 add %fp, -56, %o0
4001065c: 7f ff d6 ee call 40006214 <rtems_filesystem_eval_path_error>
40010660: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40010664: 7f ff d7 f1 call 40006628 <rtems_filesystem_eval_path_cleanup>
40010668: 90 07 bf c8 add %fp, -56, %o0
}
return rv;
}
4001066c: 81 c7 e0 08 ret
40010670: 81 e8 00 00 restore
switch (mode & S_IFMT) {
40010674: 80 a0 40 02 cmp %g1, %g2
40010678: 02 bf ff eb be 40010624 <IMFS_make_generic_node+0x50>
<== NEVER TAKEN
4001067c: 05 00 00 08 sethi %hi(0x2000), %g2
40010680: 80 a0 40 02 cmp %g1, %g2
40010684: 02 bf ff e9 be 40010628 <IMFS_make_generic_node+0x54>
<== ALWAYS TAKEN
40010688: 94 10 20 78 mov 0x78, %o2
errno = EINVAL;
4001068c: 40 00 07 7a call 40012474 <__errno>
<== NOT EXECUTED
40010690: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40010694: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40010698: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4001069c: 81 c7 e0 08 ret
<== NOT EXECUTED
400106a0: 81 e8 00 00 restore
<== NOT EXECUTED
IMFS_jnode_t *new_node = IMFS_create_node(
400106a4: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
400106a8: 9a 10 00 19 mov %i1, %o5
400106ac: d8 07 bf d4 ld [ %fp + -44 ], %o4
400106b0: d6 07 bf d0 ld [ %fp + -48 ], %o3
400106b4: 94 10 20 48 mov 0x48, %o2
400106b8: 92 10 00 1a mov %i2, %o1
400106bc: 7f ff ff a0 call 4001053c <IMFS_create_node>
400106c0: b0 10 3f ff mov -1, %i0
if ( new_node != NULL ) {
400106c4: 80 a2 20 00 cmp %o0, 0
400106c8: 02 bf ff e7 be 40010664 <IMFS_make_generic_node+0x90>
400106cc: 01 00 00 00 nop
IMFS_jnode_t *parent = currentloc->node_access;
400106d0: fa 07 60 08 ld [ %i5 + 8 ], %i5
_Timecounter_Getbintime( &now );
400106d4: 7f ff e1 d0 call 40008e14 <_Timecounter_Getbintime>
400106d8: 90 07 bf b8 add %fp, -72, %o0
return now.sec;
400106dc: c4 1f bf b8 ldd [ %fp + -72 ], %g2
jnode->stat_mtime = now;
400106e0: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
int rv = 0;
400106e4: b0 10 20 00 clr %i0
jnode->stat_ctime = now;
400106e8: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
rtems_filesystem_eval_path_cleanup( &ctx );
400106ec: 7f ff d7 cf call 40006628 <rtems_filesystem_eval_path_cleanup>
400106f0: 90 07 bf c8 add %fp, -56, %o0
}
400106f4: 81 c7 e0 08 ret
400106f8: 81 e8 00 00 restore
40004508 <IMFS_memfile_write>:
{
40004508: 9d e3 bf 90 save %sp, -112, %sp
if ( last_byte > memfile->File.size ) {
4000450c: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
last_byte = start + my_length;
40004510: 96 07 00 1a add %i4, %i2, %o3
if ( last_byte > memfile->File.size ) {
40004514: 80 a0 40 0b cmp %g1, %o3
40004518: 0a 80 00 54 bcs 40004668 <IMFS_memfile_write+0x160>
<== ALWAYS TAKEN
4000451c: a0 10 00 18 mov %i0, %l0
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
40004520: 23 10 00 5c sethi %hi(0x40017000), %l1
<== NOT EXECUTED
40004524: e4 04 60 a0 ld [ %l1 + 0xa0 ], %l2 ! 400170a0 <imfs_memfile_bytes_per_block>
40004528: bb 3c a0 1f sra %l2, 0x1f, %i5
4000452c: 96 10 00 12 mov %l2, %o3
40004530: 94 10 00 1d mov %i5, %o2
40004534: 92 10 00 1a mov %i2, %o1
40004538: 40 00 3a d8 call 40013098 <__moddi3>
4000453c: 90 10 00 19 mov %i1, %o0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40004540: 94 10 00 1d mov %i5, %o2
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
40004544: a6 10 00 09 mov %o1, %l3
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40004548: 96 10 00 12 mov %l2, %o3
4000454c: 92 10 00 1a mov %i2, %o1
40004550: 40 00 3a 47 call 40012e6c <__divdi3>
40004554: 90 10 00 19 mov %i1, %o0
40004558: ba 10 00 12 mov %l2, %i5
4000455c: b4 10 00 09 mov %o1, %i2
if ( start_offset ) {
40004560: 80 a4 e0 00 cmp %l3, 0
40004564: 12 80 00 1a bne 400045cc <IMFS_memfile_write+0xc4>
40004568: b0 10 20 00 clr %i0
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
4000456c: 80 a7 00 1d cmp %i4, %i5
40004570: 1a 80 00 0e bcc 400045a8 <IMFS_memfile_write+0xa0>
40004574: 92 10 00 1a mov %i2, %o1
if ( my_length ) {
40004578: 10 80 00 29 b 4000461c <IMFS_memfile_write+0x114>
4000457c: 80 a7 20 00 cmp %i4, 0
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
40004580: 40 00 37 fa call 40012568 <memcpy>
40004584: d0 02 00 00 ld [ %o0 ], %o0
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40004588: c2 04 60 a0 ld [ %l1 + 0xa0 ], %g1
my_length -= to_copy;
4000458c: b8 27 00 1d sub %i4, %i5, %i4
src += to_copy;
40004590: b6 06 c0 1d add %i3, %i5, %i3
block++;
40004594: b4 06 a0 01 inc %i2
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40004598: 80 a0 40 1c cmp %g1, %i4
4000459c: 18 80 00 1f bgu 40004618 <IMFS_memfile_write+0x110>
400045a0: b0 06 00 1d add %i0, %i5, %i0
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
400045a4: 92 10 00 1a mov %i2, %o1
400045a8: 94 10 20 00 clr %o2
400045ac: 7f ff fd d4 call 40003cfc <IMFS_memfile_get_block_pointer>
400045b0: 90 10 00 10 mov %l0, %o0
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
400045b4: 92 10 00 1b mov %i3, %o1
if ( !block_ptr )
400045b8: 80 a2 20 00 cmp %o0, 0
400045bc: 12 bf ff f1 bne 40004580 <IMFS_memfile_write+0x78>
<== ALWAYS TAKEN
400045c0: 94 10 00 1d mov %i5, %o2
}
400045c4: 81 c7 e0 08 ret
<== NOT EXECUTED
400045c8: 81 e8 00 00 restore
<== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
400045cc: 94 10 20 00 clr %o2
400045d0: 7f ff fd cb call 40003cfc <IMFS_memfile_get_block_pointer>
400045d4: 90 10 00 10 mov %l0, %o0
if ( !block_ptr )
400045d8: 80 a2 20 00 cmp %o0, 0
400045dc: 02 bf ff fa be 400045c4 <IMFS_memfile_write+0xbc>
<== NEVER TAKEN
400045e0: a4 24 80 13 sub %l2, %l3, %l2
400045e4: 80 a7 00 12 cmp %i4, %l2
400045e8: 18 80 00 37 bgu 400046c4 <IMFS_memfile_write+0x1bc>
400045ec: b0 10 00 1c mov %i4, %i0
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
400045f0: d0 02 00 00 ld [ %o0 ], %o0
400045f4: 92 10 00 1b mov %i3, %o1
400045f8: 94 10 00 18 mov %i0, %o2
400045fc: 90 02 00 13 add %o0, %l3, %o0
40004600: 40 00 37 da call 40012568 <memcpy>
40004604: b6 06 c0 18 add %i3, %i0, %i3
block++;
40004608: b4 06 a0 01 inc %i2
4000460c: fa 04 60 a0 ld [ %l1 + 0xa0 ], %i5
my_length -= to_copy;
40004610: 10 bf ff d7 b 4000456c <IMFS_memfile_write+0x64>
40004614: b8 27 00 18 sub %i4, %i0, %i4
if ( my_length ) {
40004618: 80 a7 20 00 cmp %i4, 0
4000461c: 02 80 00 0c be 4000464c <IMFS_memfile_write+0x144>
40004620: 94 10 20 00 clr %o2
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40004624: 92 10 00 1a mov %i2, %o1
40004628: 7f ff fd b5 call 40003cfc <IMFS_memfile_get_block_pointer>
4000462c: 90 10 00 10 mov %l0, %o0
if ( !block_ptr )
40004630: 80 a2 20 00 cmp %o0, 0
40004634: 02 bf ff e4 be 400045c4 <IMFS_memfile_write+0xbc>
<== NEVER TAKEN
40004638: 94 10 00 1c mov %i4, %o2
memcpy( &(*block_ptr)[ 0 ], src, my_length );
4000463c: d0 02 00 00 ld [ %o0 ], %o0
40004640: 92 10 00 1b mov %i3, %o1
40004644: 40 00 37 c9 call 40012568 <memcpy>
40004648: b0 06 00 1c add %i0, %i4, %i0
_Timecounter_Getbintime( &now );
4000464c: 40 00 11 f2 call 40008e14 <_Timecounter_Getbintime>
40004650: 90 07 bf f0 add %fp, -16, %o0
return now.sec;
40004654: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_mtime = now;
40004658: c4 3c 20 28 std %g2, [ %l0 + 0x28 ]
jnode->stat_ctime = now;
4000465c: c4 3c 20 30 std %g2, [ %l0 + 0x30 ]
}
40004660: 81 c7 e0 08 ret
40004664: 81 e8 00 00 restore
bool zero_fill = start > memfile->File.size;
40004668: 80 a6 60 00 cmp %i1, 0
4000466c: 04 80 00 0b ble 40004698 <IMFS_memfile_write+0x190>
<== ALWAYS TAKEN
40004670: 92 10 20 01 mov 1, %o1
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
40004674: 94 10 20 00 clr %o2
<== NOT EXECUTED
40004678: 92 0a 60 01 and %o1, 1, %o1
<== NOT EXECUTED
4000467c: 7f ff fe 49 call 40003fa0 <IMFS_memfile_extend>
<== NOT EXECUTED
40004680: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
if ( status )
40004684: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
40004688: 02 bf ff a7 be 40004524 <IMFS_memfile_write+0x1c>
<== NOT EXECUTED
4000468c: 23 10 00 5c sethi %hi(0x40017000), %l1
<== NOT EXECUTED
40004690: 81 c7 e0 08 ret
<== NOT EXECUTED
40004694: 81 e8 00 00 restore
<== NOT EXECUTED
bool zero_fill = start > memfile->File.size;
40004698: 02 80 00 16 be 400046f0 <IMFS_memfile_write+0x1e8>
<== ALWAYS TAKEN
4000469c: 80 a6 80 01 cmp %i2, %g1
400046a0: 92 10 20 00 clr %o1
<== NOT EXECUTED
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
400046a4: 94 10 20 00 clr %o2
<== NOT EXECUTED
400046a8: 92 0a 60 01 and %o1, 1, %o1
400046ac: 7f ff fe 3d call 40003fa0 <IMFS_memfile_extend>
400046b0: 90 10 00 10 mov %l0, %o0
if ( status )
400046b4: b0 92 20 00 orcc %o0, 0, %i0
400046b8: 02 bf ff 9b be 40004524 <IMFS_memfile_write+0x1c>
<== ALWAYS TAKEN
400046bc: 23 10 00 5c sethi %hi(0x40017000), %l1
400046c0: 30 bf ff f4 b,a 40004690 <IMFS_memfile_write+0x188>
<== NOT EXECUTED
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
400046c4: d0 02 00 00 ld [ %o0 ], %o0
400046c8: b0 10 00 12 mov %l2, %i0
400046cc: 92 10 00 1b mov %i3, %o1
400046d0: 94 10 00 18 mov %i0, %o2
400046d4: 90 02 00 13 add %o0, %l3, %o0
400046d8: 40 00 37 a4 call 40012568 <memcpy>
400046dc: b6 06 c0 18 add %i3, %i0, %i3
block++;
400046e0: b4 06 a0 01 inc %i2
400046e4: fa 04 60 a0 ld [ %l1 + 0xa0 ], %i5
my_length -= to_copy;
400046e8: 10 bf ff a1 b 4000456c <IMFS_memfile_write+0x64>
400046ec: b8 27 00 18 sub %i4, %i0, %i4
bool zero_fill = start > memfile->File.size;
400046f0: 18 bf ff e2 bgu 40004678 <IMFS_memfile_write+0x170>
<== NEVER TAKEN
400046f4: 94 10 20 00 clr %o2
400046f8: 10 bf ff ec b 400046a8 <IMFS_memfile_write+0x1a0>
400046fc: 92 10 20 00 clr %o1
40004764 <IMFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40004764: 9d e3 bf 80 save %sp, -128, %sp
int rv = 0;
const IMFS_fs_info_t *fs_info = parentloc->mt_entry->fs_info;
40004768: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
{
4000476c: f8 3f bf e8 std %i4, [ %fp + -24 ]
const IMFS_mknod_control *mknod_control =
get_control( fs_info->mknod_controls, mode );
40004770: c4 00 60 08 ld [ %g1 + 8 ], %g2
40004774: c6 00 a0 50 ld [ %g2 + 0x50 ], %g3
if ( S_ISDIR( mode ) ) {
40004778: 03 00 00 3c sethi %hi(0xf000), %g1
4000477c: 05 00 00 10 sethi %hi(0x4000), %g2
40004780: 82 0e c0 01 and %i3, %g1, %g1
40004784: 80 a0 40 02 cmp %g1, %g2
40004788: 02 80 00 1f be 40004804 <IMFS_mknod+0xa0>
4000478c: 05 00 00 2c sethi %hi(0xb000), %g2
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
40004790: 09 00 00 08 sethi %hi(0x2000), %g4
40004794: 84 0e c0 02 and %i3, %g2, %g2
40004798: 80 a0 80 04 cmp %g2, %g4
4000479c: 22 80 00 07 be,a 400047b8 <IMFS_mknod+0x54>
400047a0: d2 00 e0 04 ld [ %g3 + 4 ], %o1
} else if ( S_ISFIFO( mode ) ) {
400047a4: 05 00 00 04 sethi %hi(0x1000), %g2
400047a8: 80 a0 40 02 cmp %g1, %g2
400047ac: 22 80 00 03 be,a 400047b8 <IMFS_mknod+0x54>
<== NEVER TAKEN
400047b0: d2 00 e0 0c ld [ %g3 + 0xc ], %o1
<== NOT EXECUTED
return controls->file;
400047b4: d2 00 e0 08 ld [ %g3 + 8 ], %o1
IMFS_jnode_t *new_node;
new_node = IMFS_create_node(
400047b8: 82 07 bf e8 add %fp, -24, %g1
400047bc: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
400047c0: 9a 10 00 1b mov %i3, %o5
400047c4: d4 02 60 10 ld [ %o1 + 0x10 ], %o2
400047c8: 98 10 00 1a mov %i2, %o4
400047cc: 96 10 00 19 mov %i1, %o3
400047d0: 40 00 2f 5b call 4001053c <IMFS_create_node>
400047d4: 90 10 00 18 mov %i0, %o0
name,
namelen,
mode,
&dev
);
if ( new_node != NULL ) {
400047d8: 80 a2 20 00 cmp %o0, 0
400047dc: 02 80 00 0c be 4000480c <IMFS_mknod+0xa8>
<== NEVER TAKEN
400047e0: 01 00 00 00 nop
IMFS_jnode_t *parent = parentloc->node_access;
400047e4: fa 06 20 08 ld [ %i0 + 8 ], %i5
_Timecounter_Getbintime( &now );
400047e8: 40 00 11 8b call 40008e14 <_Timecounter_Getbintime>
400047ec: 90 07 bf f0 add %fp, -16, %o0
return now.sec;
400047f0: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_mtime = now;
400047f4: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
jnode->stat_ctime = now;
400047f8: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
int rv = 0;
400047fc: 81 c7 e0 08 ret
40004800: 91 e8 20 00 restore %g0, 0, %o0
return controls->directory;
40004804: 10 bf ff ed b 400047b8 <IMFS_mknod+0x54>
40004808: d2 00 c0 00 ld [ %g3 ], %o1
} else {
rv = -1;
}
return rv;
}
4000480c: 81 c7 e0 08 ret
<== NOT EXECUTED
40004810: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
40013fc8 <IMFS_mknod_control_device>:
40013fc8: 40 01 3f dc 40 00 3a 34 40 00 49 7c 40 00 49 84 @.?.@.:4@.I|@.I.
40013fd8: 00 00 00 48 ...H
40013f6c <IMFS_mknod_control_dir_default>:
40013f6c: 40 01 3f 80 40 00 37 80 40 00 37 98 40 00 49 84 @.?.@.7.@.7.@.I.
40013f7c: 00 00 00 50 ...P
4001401c <IMFS_mknod_control_enosys>:
4001401c: 40 01 45 60 40 00 3a 68 40 00 49 7c 40 00 49 84 @.E`@.:h@.I|@.I.
4001402c: 00 00 00 40 ...@
40014080 <IMFS_mknod_control_memfile>:
40014080: 40 01 40 94 40 00 3b 38 40 00 49 7c 40 00 43 a4 @.@.@.;8@.I|@.C.
40014090: 00 00 00 58 ...X
40004814 <IMFS_mount>:
#endif
#include <rtems/imfs.h>
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40004814: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40004818: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
4000481c: c4 00 60 08 ld [ %g1 + 8 ], %g2
return S_ISDIR( node->st_mode );
40004820: 07 00 00 3c sethi %hi(0xf000), %g3
40004824: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
40004828: 82 08 40 03 and %g1, %g3, %g1
if ( IMFS_is_directory( node ) ) {
4000482c: 07 00 00 10 sethi %hi(0x4000), %g3
40004830: 80 a0 40 03 cmp %g1, %g3
40004834: 12 80 00 0f bne 40004870 <IMFS_mount+0x5c>
<== NEVER TAKEN
40004838: 01 00 00 00 nop
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == NULL ) {
4000483c: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
40004840: 80 a0 60 00 cmp %g1, 0
40004844: 12 80 00 05 bne 40004858 <IMFS_mount+0x44>
<== NEVER TAKEN
40004848: 01 00 00 00 nop
dir->mt_fs = mt_entry;
4000484c: f0 20 a0 4c st %i0, [ %g2 + 0x4c ]
40004850: 81 c7 e0 08 ret
40004854: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = EBUSY;
40004858: 40 00 37 07 call 40012474 <__errno>
<== NOT EXECUTED
4000485c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004860: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
40004864: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004868: 81 c7 e0 08 ret
<== NOT EXECUTED
4000486c: 81 e8 00 00 restore
<== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40004870: 40 00 37 01 call 40012474 <__errno>
<== NOT EXECUTED
40004874: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004878: 82 10 20 14 mov 0x14, %g1
<== NOT EXECUTED
4000487c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
40004880: 81 c7 e0 08 ret
<== NOT EXECUTED
40004884: 81 e8 00 00 restore
<== NOT EXECUTED
4006494c <IMFS_node_control_linfile>:
4006494c: 40 06 49 5c 40 00 ca 08 40 00 db 88 40 00 db 90 @.I\@...@...@...
40004924 <IMFS_node_destroy>:
void IMFS_node_destroy( IMFS_jnode_t *node )
{
40004924: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
IMFS_assert( node->reference_count == 0 );
(*node->control->node_destroy)( node );
40004928: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
<== NOT EXECUTED
4000492c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
40004930: 9f c0 40 00 call %g1
<== NOT EXECUTED
40004934: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
40004938: 81 c7 e0 08 ret
<== NOT EXECUTED
4000493c: 81 e8 00 00 restore
<== NOT EXECUTED
40004984 <IMFS_node_destroy_default>:
void IMFS_node_destroy_default( IMFS_jnode_t *node )
{
40004984: 9d e3 bf a0 save %sp, -96, %sp
if ( ( node->flags & IMFS_NODE_FLAG_NAME_ALLOCATED ) != 0 ) {
40004988: c2 16 20 12 lduh [ %i0 + 0x12 ], %g1
4000498c: 80 88 60 01 btst 1, %g1
40004990: 12 80 00 04 bne 400049a0 <IMFS_node_destroy_default+0x1c> <== NEVER TAKEN
40004994: 01 00 00 00 nop
free( RTEMS_DECONST( char *, node->name ) );
}
free( node );
40004998: 40 00 01 72 call 40004f60 <free>
4000499c: 81 e8 00 00 restore
free( RTEMS_DECONST( char *, node->name ) );
400049a0: 40 00 01 70 call 40004f60 <free>
<== NOT EXECUTED
400049a4: d0 06 20 0c ld [ %i0 + 0xc ], %o0
<== NOT EXECUTED
free( node );
400049a8: 40 00 01 6e call 40004f60 <free>
<== NOT EXECUTED
400049ac: 81 e8 00 00 restore
<== NOT EXECUTED
40003798 <IMFS_node_remove_directory>:
{
return dir->mt_fs != NULL;
}
IMFS_jnode_t *IMFS_node_remove_directory( IMFS_jnode_t *node )
{
40003798: 9d e3 bf a0 save %sp, -96, %sp
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( !rtems_chain_is_empty( &dir->Entries ) ) {
4000379c: c4 06 20 40 ld [ %i0 + 0x40 ], %g2
return &the_chain->Tail.Node;
400037a0: 82 06 20 44 add %i0, 0x44, %g1
400037a4: 80 a0 80 01 cmp %g2, %g1
400037a8: 12 80 00 0c bne 400037d8 <IMFS_node_remove_directory+0x40> <== NEVER TAKEN
400037ac: 01 00 00 00 nop
errno = ENOTEMPTY;
dir = NULL;
} else if ( IMFS_is_mount_point( dir ) ) {
400037b0: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
400037b4: 80 a0 60 00 cmp %g1, 0
400037b8: 02 80 00 0c be 400037e8 <IMFS_node_remove_directory+0x50> <== ALWAYS TAKEN
400037bc: 01 00 00 00 nop
errno = EBUSY;
400037c0: 40 00 3b 2d call 40012474 <__errno>
<== NOT EXECUTED
400037c4: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
400037c8: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
400037cc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
dir = NULL;
}
return &dir->Node;
}
400037d0: 81 c7 e0 08 ret
<== NOT EXECUTED
400037d4: 81 e8 00 00 restore
<== NOT EXECUTED
errno = ENOTEMPTY;
400037d8: 40 00 3b 27 call 40012474 <__errno>
<== NOT EXECUTED
400037dc: b0 10 20 00 clr %i0
<== NOT EXECUTED
400037e0: 82 10 20 5a mov 0x5a, %g1
<== NOT EXECUTED
400037e4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400037e8: 81 c7 e0 08 ret
400037ec: 81 e8 00 00 restore
40004c4c <IMFS_readlink>:
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40004c4c: 80 a2 a0 00 cmp %o2, 0
<== NOT EXECUTED
40004c50: 02 80 00 16 be 40004ca8 <IMFS_readlink+0x5c>
<== NOT EXECUTED
40004c54: c6 02 20 08 ld [ %o0 + 8 ], %g3
<== NOT EXECUTED
40004c58: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
<== NOT EXECUTED
40004c5c: c4 48 40 00 ldsb [ %g1 ], %g2
<== NOT EXECUTED
40004c60: 90 10 20 00 clr %o0
<== NOT EXECUTED
40004c64: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40004c68: 12 80 00 07 bne 40004c84 <IMFS_readlink+0x38>
<== NOT EXECUTED
40004c6c: c2 08 40 00 ldub [ %g1 ], %g1
<== NOT EXECUTED
40004c70: 30 80 00 0c b,a 40004ca0 <IMFS_readlink+0x54>
<== NOT EXECUTED
40004c74: c4 48 40 08 ldsb [ %g1 + %o0 ], %g2
<== NOT EXECUTED
40004c78: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40004c7c: 02 80 00 07 be 40004c98 <IMFS_readlink+0x4c>
<== NOT EXECUTED
40004c80: c2 08 40 08 ldub [ %g1 + %o0 ], %g1
<== NOT EXECUTED
buf[i] = sym_link->name[i];
40004c84: c2 2a 40 08 stb %g1, [ %o1 + %o0 ]
<== NOT EXECUTED
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40004c88: 90 02 20 01 inc %o0
<== NOT EXECUTED
40004c8c: 80 a2 80 08 cmp %o2, %o0
<== NOT EXECUTED
40004c90: 32 bf ff f9 bne,a 40004c74 <IMFS_readlink+0x28>
<== NOT EXECUTED
40004c94: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
<== NOT EXECUTED
}
40004c98: 81 c3 e0 08 retl
<== NOT EXECUTED
40004c9c: 01 00 00 00 nop
<== NOT EXECUTED
40004ca0: 81 c3 e0 08 retl
<== NOT EXECUTED
40004ca4: 01 00 00 00 nop
<== NOT EXECUTED
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40004ca8: 81 c3 e0 08 retl
<== NOT EXECUTED
40004cac: 90 10 20 00 clr %o0 ! 0 <PROM_START>
<== NOT EXECUTED
400049b0 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
400049b0: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
IMFS_jnode_t *node = oldloc->node_access;
400049b4: 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 ) {
400049b8: c2 07 60 08 ld [ %i5 + 8 ], %g1
<== NOT EXECUTED
400049bc: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
400049c0: 02 80 00 36 be 40004a98 <IMFS_rename+0xe8>
<== NOT EXECUTED
400049c4: f4 06 a0 08 ld [ %i2 + 8 ], %i2
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( namelen >= IMFS_NAME_MAX ) {
400049c8: 80 a7 20 fe cmp %i4, 0xfe
<== NOT EXECUTED
400049cc: 18 80 00 27 bgu 40004a68 <IMFS_rename+0xb8>
<== NOT EXECUTED
400049d0: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
}
allocated_name = malloc( namelen );
400049d4: 40 00 02 d8 call 40005534 <malloc>
<== NOT EXECUTED
400049d8: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
if ( allocated_name == NULL ) {
400049dc: b2 92 20 00 orcc %o0, 0, %i1
<== NOT EXECUTED
400049e0: 02 80 00 28 be 40004a80 <IMFS_rename+0xd0>
<== NOT EXECUTED
400049e4: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
memcpy( allocated_name, name, namelen );
400049e8: 40 00 36 e0 call 40012568 <memcpy>
<== NOT EXECUTED
400049ec: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
if ( ( node->flags & IMFS_NODE_FLAG_NAME_ALLOCATED ) != 0 ) {
400049f0: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1
<== NOT EXECUTED
400049f4: 80 88 60 01 btst 1, %g1
<== NOT EXECUTED
400049f8: 12 80 00 18 bne 40004a58 <IMFS_rename+0xa8>
<== NOT EXECUTED
400049fc: 01 00 00 00 nop
<== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
40004a00: c6 07 40 00 ld [ %i5 ], %g3
<== NOT EXECUTED
previous = the_node->previous;
40004a04: c4 07 60 04 ld [ %i5 + 4 ], %g2
<== NOT EXECUTED
free( RTEMS_DECONST( char *, node->name ) );
}
node->name = allocated_name;
40004a08: f2 27 60 0c st %i1, [ %i5 + 0xc ]
<== NOT EXECUTED
node->namelen = namelen;
node->flags |= IMFS_NODE_FLAG_NAME_ALLOCATED;
40004a0c: 82 10 60 01 or %g1, 1, %g1
<== NOT EXECUTED
node->namelen = namelen;
40004a10: f8 37 60 10 sth %i4, [ %i5 + 0x10 ]
<== NOT EXECUTED
return &the_chain->Tail.Node;
40004a14: 88 06 a0 44 add %i2, 0x44, %g4
<== NOT EXECUTED
node->flags |= IMFS_NODE_FLAG_NAME_ALLOCATED;
40004a18: c2 37 60 12 sth %g1, [ %i5 + 0x12 ]
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
40004a1c: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
next->previous = previous;
40004a20: c4 20 e0 04 st %g2, [ %g3 + 4 ]
<== NOT EXECUTED
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
return 0;
40004a24: b0 10 20 00 clr %i0
<== NOT EXECUTED
previous->next = next;
40004a28: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
Chain_Node *old_last;
_Assert( _Chain_Is_node_off_chain( the_node ) );
tail = _Chain_Tail( the_chain );
old_last = tail->previous;
40004a2c: c2 06 a0 48 ld [ %i2 + 0x48 ], %g1
<== NOT EXECUTED
entry_node->Parent = dir_node;
40004a30: f4 27 60 08 st %i2, [ %i5 + 8 ]
<== NOT EXECUTED
the_node->next = tail;
40004a34: c8 27 40 00 st %g4, [ %i5 ]
<== NOT EXECUTED
tail->previous = the_node;
40004a38: fa 26 a0 48 st %i5, [ %i2 + 0x48 ]
<== NOT EXECUTED
old_last->next = the_node;
40004a3c: fa 20 40 00 st %i5, [ %g1 ]
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
40004a40: 40 00 10 f5 call 40008e14 <_Timecounter_Getbintime>
<== NOT EXECUTED
40004a44: c2 27 60 04 st %g1, [ %i5 + 4 ]
<== NOT EXECUTED
return now.sec;
40004a48: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_ctime = _IMFS_get_time();
40004a4c: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
<== NOT EXECUTED
}
40004a50: 81 c7 e0 08 ret
<== NOT EXECUTED
40004a54: 81 e8 00 00 restore
<== NOT EXECUTED
free( RTEMS_DECONST( char *, node->name ) );
40004a58: 40 00 01 42 call 40004f60 <free>
<== NOT EXECUTED
40004a5c: d0 07 60 0c ld [ %i5 + 0xc ], %o0
<== NOT EXECUTED
40004a60: 10 bf ff e8 b 40004a00 <IMFS_rename+0x50>
<== NOT EXECUTED
40004a64: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
40004a68: 40 00 36 83 call 40012474 <__errno>
<== NOT EXECUTED
40004a6c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004a70: 82 10 20 5b mov 0x5b, %g1
<== NOT EXECUTED
40004a74: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004a78: 81 c7 e0 08 ret
<== NOT EXECUTED
40004a7c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
40004a80: 40 00 36 7d call 40012474 <__errno>
<== NOT EXECUTED
40004a84: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004a88: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40004a8c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004a90: 81 c7 e0 08 ret
<== NOT EXECUTED
40004a94: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
40004a98: 40 00 36 77 call 40012474 <__errno>
<== NOT EXECUTED
40004a9c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004aa0: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40004aa4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004aa8: 81 c7 e0 08 ret
<== NOT EXECUTED
40004aac: 81 e8 00 00 restore
<== NOT EXECUTED
40004ab0 <IMFS_rmnod>:
int IMFS_rmnod(
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
40004ab0: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = loc->node_access;
40004ab4: d0 06 60 08 ld [ %i1 + 8 ], %o0
node = (*node->control->node_remove)( node );
40004ab8: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
40004abc: c2 00 60 08 ld [ %g1 + 8 ], %g1
40004ac0: 9f c0 40 00 call %g1
40004ac4: 01 00 00 00 nop
if ( node != NULL ) {
40004ac8: 80 a2 20 00 cmp %o0, 0
40004acc: 22 80 00 11 be,a 40004b10 <IMFS_rmnod+0x60>
<== NEVER TAKEN
40004ad0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
--node->reference_count;
40004ad4: c4 12 20 18 lduh [ %o0 + 0x18 ], %g2
--node->st_nlink;
40004ad8: c2 12 20 1a lduh [ %o0 + 0x1a ], %g1
40004adc: 82 00 7f ff add %g1, -1, %g1
--node->reference_count;
40004ae0: 84 00 bf ff add %g2, -1, %g2
--node->st_nlink;
40004ae4: c2 32 20 1a sth %g1, [ %o0 + 0x1a ]
--node->reference_count;
40004ae8: c4 32 20 18 sth %g2, [ %o0 + 0x18 ]
if ( node->Parent != NULL ) {
40004aec: c2 02 20 08 ld [ %o0 + 8 ], %g1
40004af0: 80 a0 60 00 cmp %g1, 0
40004af4: 02 80 00 07 be 40004b10 <IMFS_rmnod+0x60>
<== NEVER TAKEN
40004af8: b0 10 20 00 clr %i0
node->Parent = NULL;
40004afc: c0 22 20 08 clr [ %o0 + 8 ]
next = the_node->next;
40004b00: c4 02 00 00 ld [ %o0 ], %g2
previous = the_node->previous;
40004b04: c2 02 20 04 ld [ %o0 + 4 ], %g1
next->previous = previous;
40004b08: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40004b0c: c4 20 40 00 st %g2, [ %g1 ]
40004b10: 81 c7 e0 08 ret
40004b14: 81 e8 00 00 restore
} else {
rv = -1;
}
return rv;
}
40004b18: 81 c7 e0 08 ret
<== NOT EXECUTED
40004b1c: 81 e8 00 00 restore
<== NOT EXECUTED
40004be8 <IMFS_symlink>:
{
40004be8: 9d e3 bf 98 save %sp, -104, %sp
sizeof( IMFS_sym_link_t ) + strlen( target ) + 1,
40004bec: 40 00 37 94 call 40012a3c <strlen>
40004bf0: 90 10 00 1b mov %i3, %o0
new_node = IMFS_create_node(
40004bf4: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
40004bf8: 94 02 20 49 add %o0, 0x49, %o2
40004bfc: 98 10 00 1a mov %i2, %o4
40004c00: 90 10 00 18 mov %i0, %o0
40004c04: 1b 00 00 28 sethi %hi(0xa000), %o5
40004c08: 96 10 00 19 mov %i1, %o3
40004c0c: 9a 13 61 ff or %o5, 0x1ff, %o5
40004c10: 13 10 00 50 sethi %hi(0x40014000), %o1
return 0;
40004c14: b0 10 20 00 clr %i0
new_node = IMFS_create_node(
40004c18: 40 00 2e 49 call 4001053c <IMFS_create_node>
40004c1c: 92 12 61 14 or %o1, 0x114, %o1
if ( new_node == NULL ) {
40004c20: 80 a2 20 00 cmp %o0, 0
40004c24: 02 80 00 04 be 40004c34 <IMFS_symlink+0x4c>
<== NEVER TAKEN
40004c28: 01 00 00 00 nop
}
40004c2c: 81 c7 e0 08 ret
40004c30: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( ENOMEM );
40004c34: 40 00 36 10 call 40012474 <__errno>
<== NOT EXECUTED
40004c38: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004c3c: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40004c40: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40004c44: 81 c7 e0 08 ret
<== NOT EXECUTED
40004c48: 81 e8 00 00 restore
<== NOT EXECUTED
40004cb0 <IMFS_unmount>:
#endif
#include <rtems/imfs.h>
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40004cb0: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40004cb4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40004cb8: c4 00 60 08 ld [ %g1 + 8 ], %g2
return S_ISDIR( node->st_mode );
40004cbc: 07 00 00 3c sethi %hi(0xf000), %g3
40004cc0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
40004cc4: 82 08 40 03 and %g1, %g3, %g1
if ( IMFS_is_directory( node ) ) {
40004cc8: 07 00 00 10 sethi %hi(0x4000), %g3
40004ccc: 80 a0 40 03 cmp %g1, %g3
40004cd0: 12 80 00 0f bne 40004d0c <IMFS_unmount+0x5c>
<== NEVER TAKEN
40004cd4: 01 00 00 00 nop
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == mt_entry ) {
40004cd8: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
40004cdc: 80 a0 40 18 cmp %g1, %i0
40004ce0: 12 80 00 05 bne 40004cf4 <IMFS_unmount+0x44>
<== NEVER TAKEN
40004ce4: 01 00 00 00 nop
dir->mt_fs = NULL;
40004ce8: c0 20 a0 4c clr [ %g2 + 0x4c ]
40004cec: 81 c7 e0 08 ret
40004cf0: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = EINVAL;
40004cf4: 40 00 35 e0 call 40012474 <__errno>
<== NOT EXECUTED
40004cf8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004cfc: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40004d00: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40004d04: 81 c7 e0 08 ret
<== NOT EXECUTED
40004d08: 81 e8 00 00 restore
<== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40004d0c: 40 00 35 da call 40012474 <__errno>
<== NOT EXECUTED
40004d10: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004d14: 82 10 20 14 mov 0x14, %g1
<== NOT EXECUTED
40004d18: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
40004d1c: 81 c7 e0 08 ret
<== NOT EXECUTED
40004d20: 81 e8 00 00 restore
<== NOT EXECUTED
40004d24 <IMFS_utime>:
int IMFS_utime(
const rtems_filesystem_location_info_t *loc,
time_t actime,
time_t modtime
)
{
40004d24: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) loc->node_access;
40004d28: fa 06 20 08 ld [ %i0 + 8 ], %i5
<== NOT EXECUTED
{
40004d2c: 84 10 00 1b mov %i3, %g2
<== NOT EXECUTED
40004d30: b0 10 00 19 mov %i1, %i0
<== NOT EXECUTED
40004d34: 86 10 00 1c mov %i4, %g3
<== NOT EXECUTED
40004d38: b2 10 00 1a mov %i2, %i1
<== NOT EXECUTED
the_jnode->stat_atime = actime;
the_jnode->stat_mtime = modtime;
40004d3c: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
<== NOT EXECUTED
the_jnode->stat_ctime = time( NULL );
40004d40: 90 10 20 00 clr %o0
<== NOT EXECUTED
the_jnode->stat_atime = actime;
40004d44: f0 3f 60 20 std %i0, [ %i5 + 0x20 ]
<== NOT EXECUTED
the_jnode->stat_ctime = time( NULL );
40004d48: 40 00 37 6d call 40012afc <time>
<== NOT EXECUTED
40004d4c: b0 10 20 00 clr %i0
<== NOT EXECUTED
40004d50: d0 3f 60 30 std %o0, [ %i5 + 0x30 ]
<== NOT EXECUTED
return 0;
}
40004d54: 81 c7 e0 08 ret
<== NOT EXECUTED
40004d58: 81 e8 00 00 restore
<== NOT EXECUTED
4001043c <device_ftruncate>:
rtems_libio_t *iop,
off_t length
)
{
return 0;
}
4001043c: 81 c3 e0 08 retl
<== NOT EXECUTED
40010440: 90 10 20 00 clr %o0
<== NOT EXECUTED
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
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
4000cba0: 92 10 00 18 mov %i0, %o1
4000cba4: 40 00 1a fe call 4001379c <rtems_filesystem_eval_path_start>
4000cba8: 90 07 be 00 add %fp, -512, %o0
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