40004d08 <IMFS_add_node>:
#endif
#include <rtems/imfs.h>
int IMFS_add_node( const char *path, IMFS_jnode_t *node, void *arg )
{
40004d08: 9d e3 bf 58 save %sp, -168, %sp
const rtems_filesystem_location_info_t *currentloc;
int eval_flags;
int rv;
mode = node->st_mode;
mode &= ~rtems_filesystem_umask;
40004d0c: 7f ff ff 59 call 40004a70 <rtems_current_user_env_get>
40004d10: fa 06 60 14 ld [ %i1 + 0x14 ], %i5
40004d14: c2 02 20 08 ld [ %o0 + 8 ], %g1
40004d18: ba 2f 40 01 andn %i5, %g1, %i5
switch (mode & S_IFMT) {
40004d1c: 05 00 00 18 sethi %hi(0x6000), %g2
40004d20: 03 00 00 3c sethi %hi(0xf000), %g1
40004d24: 82 0f 40 01 and %i5, %g1, %g1
40004d28: 80 a0 40 02 cmp %g1, %g2
40004d2c: 02 80 00 0c be 40004d5c <IMFS_add_node+0x54>
40004d30: 94 10 20 18 mov 0x18, %o2
40004d34: 08 80 00 1c bleu 40004da4 <IMFS_add_node+0x9c>
40004d38: 05 00 00 04 sethi %hi(0x1000), %g2
40004d3c: 05 00 00 20 sethi %hi(0x8000), %g2
<== NOT EXECUTED
40004d40: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40004d44: 02 80 00 06 be 40004d5c <IMFS_add_node+0x54>
<== NOT EXECUTED
40004d48: 05 00 00 30 sethi %hi(0xc000), %g2
<== NOT EXECUTED
40004d4c: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40004d50: 12 80 00 1b bne 40004dbc <IMFS_add_node+0xb4>
<== NOT EXECUTED
40004d54: 01 00 00 00 nop
<== NOT EXECUTED
errno = EINVAL;
return -1;
}
eval_flags = RTEMS_FS_FOLLOW_LINK;
currentloc = rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
40004d58: 94 10 20 18 mov 0x18, %o2 ! 18 <_TLS_Alignment+0x17>
<== NOT EXECUTED
40004d5c: 92 10 00 18 mov %i0, %o1
40004d60: 7f ff fd 76 call 40004338 <rtems_filesystem_eval_path_start>
40004d64: 90 07 bf c8 add %fp, -56, %o0
static inline bool IMFS_is_imfs_instance(
const rtems_filesystem_location_info_t *loc
)
{
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
40004d68: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40004d6c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
if ( IMFS_is_imfs_instance( currentloc ) ) {
40004d70: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
40004d74: 03 10 00 18 sethi %hi(0x40006000), %g1
40004d78: 82 10 60 f0 or %g1, 0xf0, %g1 ! 400060f0 <IMFS_node_clone>
40004d7c: 80 a0 80 01 cmp %g2, %g1
40004d80: 02 80 00 15 be 40004dd4 <IMFS_add_node+0xcc>
40004d84: 92 10 20 86 mov 0x86, %o1
}
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
40004d88: 90 07 bf c8 add %fp, -56, %o0
40004d8c: 7f ff fc b0 call 4000404c <rtems_filesystem_eval_path_error>
40004d90: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40004d94: 7f ff fd 75 call 40004368 <rtems_filesystem_eval_path_cleanup>
40004d98: 90 07 bf c8 add %fp, -56, %o0
return rv;
}
40004d9c: 81 c7 e0 08 ret
40004da0: 81 e8 00 00 restore
switch (mode & S_IFMT) {
40004da4: 80 a0 40 02 cmp %g1, %g2
40004da8: 02 bf ff ec be 40004d58 <IMFS_add_node+0x50>
40004dac: 05 00 00 08 sethi %hi(0x2000), %g2
40004db0: 80 a0 40 02 cmp %g1, %g2
40004db4: 02 bf ff ea be 40004d5c <IMFS_add_node+0x54>
40004db8: 94 10 20 18 mov 0x18, %o2
errno = EINVAL;
40004dbc: 40 00 29 81 call 4000f3c0 <__errno>
40004dc0: b0 10 3f ff mov -1, %i0
40004dc4: 82 10 20 16 mov 0x16, %g1
40004dc8: c2 22 00 00 st %g1, [ %o0 ]
return -1;
40004dcc: 81 c7 e0 08 ret
40004dd0: 81 e8 00 00 restore
ctx->path = path;
40004dd4: c4 06 60 0c ld [ %i1 + 0xc ], %g2
rtems_filesystem_eval_path_set_path( &ctx, node->name, node->namelen );
40004dd8: c2 16 60 10 lduh [ %i1 + 0x10 ], %g1
40004ddc: c4 27 bf c8 st %g2, [ %fp + -56 ]
ctx->flags = flags;
40004de0: 84 10 20 60 mov 0x60, %g2
ctx->pathlen = pathlen;
40004de4: c2 27 bf cc st %g1, [ %fp + -52 ]
rtems_filesystem_eval_path_continue( &ctx );
40004de8: 90 07 bf c8 add %fp, -56, %o0
40004dec: 7f ff fc e0 call 4000416c <rtems_filesystem_eval_path_continue>
40004df0: c4 27 bf d8 st %g2, [ %fp + -40 ]
if ( rtems_filesystem_eval_path_get_token( &ctx ) == node->name ) {
40004df4: c2 07 bf d0 ld [ %fp + -48 ], %g1
40004df8: d4 06 60 0c ld [ %i1 + 0xc ], %o2
40004dfc: 80 a2 80 01 cmp %o2, %g1
40004e00: 02 80 00 0b be 40004e2c <IMFS_add_node+0x124>
40004e04: 80 a0 60 00 cmp %g1, 0
if ( rtems_filesystem_eval_path_get_token( &ctx ) != NULL ) {
40004e08: 02 80 00 12 be 40004e50 <IMFS_add_node+0x148>
40004e0c: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_error( &ctx, EINVAL );
40004e10: 7f ff fc 8f call 4000404c <rtems_filesystem_eval_path_error>
40004e14: 92 10 20 16 mov 0x16, %o1
rv = -1;
40004e18: b0 10 3f ff mov -1, %i0
rtems_filesystem_eval_path_cleanup( &ctx );
40004e1c: 7f ff fd 53 call 40004368 <rtems_filesystem_eval_path_cleanup>
40004e20: 90 07 bf c8 add %fp, -56, %o0
}
40004e24: 81 c7 e0 08 ret
40004e28: 81 e8 00 00 restore
node = IMFS_initialize_node(
40004e2c: d6 16 60 10 lduh [ %i1 + 0x10 ], %o3
40004e30: d2 06 60 38 ld [ %i1 + 0x38 ], %o1
40004e34: 9a 10 00 1a mov %i2, %o5
40004e38: 98 10 00 1d mov %i5, %o4
40004e3c: 40 00 04 8d call 40006070 <IMFS_initialize_node>
40004e40: 90 10 00 19 mov %i1, %o0
if ( node != NULL ) {
40004e44: 82 92 20 00 orcc %o0, 0, %g1
40004e48: 12 80 00 07 bne 40004e64 <IMFS_add_node+0x15c>
40004e4c: fa 07 bf e8 ld [ %fp + -24 ], %i5
rv = -1;
40004e50: b0 10 3f ff mov -1, %i0
rtems_filesystem_eval_path_cleanup( &ctx );
40004e54: 7f ff fd 45 call 40004368 <rtems_filesystem_eval_path_cleanup>
40004e58: 90 07 bf c8 add %fp, -56, %o0
}
40004e5c: 81 c7 e0 08 ret
40004e60: 81 e8 00 00 restore
old_last = tail->previous;
40004e64: c4 07 60 48 ld [ %i5 + 0x48 ], %g2
return &the_chain->Tail.Node;
40004e68: 86 07 60 44 add %i5, 0x44, %g3
IMFS_jnode_t *entry_node
)
{
IMFS_directory_t *dir = (IMFS_directory_t *) dir_node;
entry_node->Parent = dir_node;
40004e6c: fa 20 60 08 st %i5, [ %g1 + 8 ]
_Timecounter_Getbintime( &now );
40004e70: 90 07 bf b8 add %fp, -72, %o0
the_node->next = tail;
40004e74: c6 20 40 00 st %g3, [ %g1 ]
rv = 0;
40004e78: b0 10 20 00 clr %i0
tail->previous = the_node;
40004e7c: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
old_last->next = the_node;
40004e80: c2 20 80 00 st %g1, [ %g2 ]
40004e84: 40 00 17 f2 call 4000ae4c <_Timecounter_Getbintime>
40004e88: c4 20 60 04 st %g2, [ %g1 + 4 ]
return now.sec;
40004e8c: c4 1f bf b8 ldd [ %fp + -72 ], %g2
jnode->stat_mtime = now;
40004e90: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
40004e94: 10 bf ff c0 b 40004d94 <IMFS_add_node+0x8c>
40004e98: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
4000c260 <IMFS_create_node>:
const char *name,
size_t namelen,
mode_t mode,
void *arg
)
{
4000c260: 9d e3 bf a0 save %sp, -96, %sp
IMFS_jnode_t *allocated_node;
char *allocated_name;
IMFS_jnode_t *node;
allocated_node = calloc( 1, node_size + namelen );
4000c264: 90 10 20 01 mov 1, %o0
4000c268: 7f ff fd df call 4000b9e4 <calloc>
4000c26c: 92 06 80 1c add %i2, %i4, %o1
if ( allocated_node == NULL ) {
4000c270: a0 92 20 00 orcc %o0, 0, %l0
4000c274: 02 80 00 1d be 4000c2e8 <IMFS_create_node+0x88>
4000c278: 94 10 00 1c mov %i4, %o2
return NULL;
}
allocated_name = (char *) allocated_node + node_size;
allocated_name = memcpy( allocated_name, name, namelen );
4000c27c: 92 10 00 1b mov %i3, %o1
4000c280: 40 00 0d 0b call 4000f6ac <memcpy>
4000c284: 90 04 00 1a add %l0, %i2, %o0
node = IMFS_initialize_node(
4000c288: da 07 a0 5c ld [ %fp + 0x5c ], %o5
4000c28c: 98 10 00 1d mov %i5, %o4
4000c290: 94 10 00 08 mov %o0, %o2
4000c294: 96 10 00 1c mov %i4, %o3
4000c298: 92 10 00 19 mov %i1, %o1
4000c29c: 7f ff e7 75 call 40006070 <IMFS_initialize_node>
4000c2a0: 90 10 00 10 mov %l0, %o0
allocated_name,
namelen,
mode,
arg
);
if ( node != NULL ) {
4000c2a4: ba 92 20 00 orcc %o0, 0, %i5
4000c2a8: 02 80 00 0c be 4000c2d8 <IMFS_create_node+0x78>
4000c2ac: 90 10 00 10 mov %l0, %o0
IMFS_jnode_t *parent = parentloc->node_access;
4000c2b0: c2 06 20 08 ld [ %i0 + 8 ], %g1
old_last = tail->previous;
4000c2b4: c4 00 60 48 ld [ %g1 + 0x48 ], %g2
return &the_chain->Tail.Node;
4000c2b8: 86 00 60 44 add %g1, 0x44, %g3
entry_node->Parent = dir_node;
4000c2bc: c2 27 60 08 st %g1, [ %i5 + 8 ]
the_node->next = tail;
4000c2c0: c6 27 40 00 st %g3, [ %i5 ]
tail->previous = the_node;
4000c2c4: fa 20 60 48 st %i5, [ %g1 + 0x48 ]
old_last->next = the_node;
4000c2c8: fa 20 80 00 st %i5, [ %g2 ]
the_node->previous = old_last;
4000c2cc: c4 27 60 04 st %g2, [ %i5 + 4 ]
} else {
free( allocated_node );
}
return node;
}
4000c2d0: 81 c7 e0 08 ret
4000c2d4: 91 e8 00 1d restore %g0, %i5, %o0
free( allocated_node );
4000c2d8: 7f ff dc 79 call 400034bc <free>
4000c2dc: b0 10 00 1d mov %i5, %i0
}
4000c2e0: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c2e4: 81 e8 00 00 restore
errno = ENOMEM;
4000c2e8: 40 00 0c 36 call 4000f3c0 <__errno>
4000c2ec: ba 10 20 00 clr %i5
4000c2f0: 82 10 20 0c mov 0xc, %g1
return NULL;
4000c2f4: 10 bf ff f7 b 4000c2d0 <IMFS_create_node+0x70>
4000c2f8: c2 22 00 00 st %g1, [ %o0 ]
40006168 <IMFS_do_nothing_destroy>:
void IMFS_do_nothing_destroy( IMFS_jnode_t *node )
{
(void) node;
}
40006168: 81 c3 e0 08 retl
<== NOT EXECUTED
4000616c: 01 00 00 00 nop
<== NOT EXECUTED
40003bd0 <IMFS_eval_path_devfs>:
return NULL;
}
void IMFS_eval_path_devfs( rtems_filesystem_eval_path_context_t *ctx )
{
40003bd0: 9d e3 bf a0 save %sp, -96, %sp
pathlen = rtems_filesystem_eval_path_get_pathlen( ctx );
40003bd4: f8 06 20 04 ld [ %i0 + 4 ], %i4
&& memcmp( IMFS_devfs_dirs[ i ].name, path, pathlen ) == 0;
40003bd8: 37 10 00 31 sethi %hi(0x4000c400), %i3
pathlen = rtems_filesystem_eval_path_get_pathlen( ctx );
40003bdc: 82 10 20 01 mov 1, %g1
&& memcmp( IMFS_devfs_dirs[ i ].name, path, pathlen ) == 0;
40003be0: b6 16 e1 64 or %i3, 0x164, %i3
match = IMFS_devfs_dirs[ i ].len == pathlen
40003be4: 82 08 60 ff and %g1, 0xff, %g1
rtems_filesystem_location_info_t *currentloc;
IMFS_directory_t *dir;
IMFS_jnode_t *entry;
currentloc = rtems_filesystem_eval_path_get_currentloc( ctx );
dir = currentloc->node_access;
40003be8: f2 06 20 20 ld [ %i0 + 0x20 ], %i1
path = rtems_filesystem_eval_path_get_path( ctx );
40003bec: f4 06 00 00 ld [ %i0 ], %i2
pathlen = rtems_filesystem_eval_path_get_pathlen( ctx );
40003bf0: ba 10 20 00 clr %i5
&& memcmp( IMFS_devfs_dirs[ i ].name, path, pathlen ) == 0;
40003bf4: 80 a7 00 01 cmp %i4, %g1
40003bf8: 02 80 00 0b be 40003c24 <IMFS_eval_path_devfs+0x54>
40003bfc: a0 06 e0 01 add %i3, 1, %l0
40003c00: ba 07 60 04 add %i5, 4, %i5
for ( i = 0; i < RTEMS_ARRAY_SIZE( IMFS_devfs_dirs ); ++i ) {
40003c04: 80 a7 60 10 cmp %i5, 0x10
40003c08: 22 80 00 16 be,a 40003c60 <IMFS_eval_path_devfs+0x90>
40003c0c: fa 06 60 40 ld [ %i1 + 0x40 ], %i5
40003c10: c2 0e c0 1d ldub [ %i3 + %i5 ], %g1
match = IMFS_devfs_dirs[ i ].len == pathlen
40003c14: 82 08 60 ff and %g1, 0xff, %g1
&& memcmp( IMFS_devfs_dirs[ i ].name, path, pathlen ) == 0;
40003c18: 80 a7 00 01 cmp %i4, %g1
40003c1c: 32 bf ff fa bne,a 40003c04 <IMFS_eval_path_devfs+0x34>
40003c20: ba 07 60 04 add %i5, 4, %i5
40003c24: 94 10 00 1c mov %i4, %o2
40003c28: 92 10 00 1a mov %i2, %o1
40003c2c: 40 00 1f 70 call 4000b9ec <memcmp>
40003c30: 90 04 00 1d add %l0, %i5, %o0
40003c34: 80 a2 20 00 cmp %o0, 0
40003c38: 32 bf ff f3 bne,a 40003c04 <IMFS_eval_path_devfs+0x34> <== NEVER TAKEN
40003c3c: ba 07 60 04 add %i5, 4, %i5
<== NOT EXECUTED
eval_flags &= ~RTEMS_FS_EXCLUSIVE;
40003c40: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
40003c44: 82 08 7f bf and %g1, -65, %g1
ctx->pathlen = 0;
40003c48: c0 26 20 04 clr [ %i0 + 4 ]
40003c4c: b8 10 20 00 clr %i4
entry = IMFS_devfs_is_dir( ctx, dir );
if ( entry != NULL ) {
40003c50: 80 a6 60 00 cmp %i1, 0
40003c54: 12 80 00 28 bne 40003cf4 <IMFS_eval_path_devfs+0x124>
40003c58: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
return _Chain_Immutable_head( the_chain )->next;
40003c5c: fa 06 60 40 ld [ %i1 + 0x40 ], %i5
<== NOT EXECUTED
return &the_chain->Tail.Node;
40003c60: b6 06 60 44 add %i1, 0x44, %i3
while ( current != tail ) {
40003c64: 80 a7 40 1b cmp %i5, %i3
40003c68: 32 80 00 08 bne,a 40003c88 <IMFS_eval_path_devfs+0xb8> <== ALWAYS TAKEN
40003c6c: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1
ctx->token = token;
40003c70: 10 80 00 23 b 40003cfc <IMFS_eval_path_devfs+0x12c>
<== NOT EXECUTED
40003c74: f4 26 20 08 st %i2, [ %i0 + 8 ]
<== NOT EXECUTED
40003c78: 80 a6 c0 1d cmp %i3, %i5
40003c7c: 22 80 00 20 be,a 40003cfc <IMFS_eval_path_devfs+0x12c>
40003c80: f4 26 20 08 st %i2, [ %i0 + 8 ]
match = entry->namelen == pathlen
40003c84: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1
&& memcmp( entry->name, path, pathlen ) == 0;
40003c88: 80 a0 40 1c cmp %g1, %i4
40003c8c: 32 bf ff fb bne,a 40003c78 <IMFS_eval_path_devfs+0xa8>
40003c90: fa 07 40 00 ld [ %i5 ], %i5
40003c94: d0 07 60 0c ld [ %i5 + 0xc ], %o0
40003c98: 94 10 00 1c mov %i4, %o2
40003c9c: 40 00 1f 54 call 4000b9ec <memcmp>
40003ca0: 92 10 00 1a mov %i2, %o1
40003ca4: 80 a2 20 00 cmp %o0, 0
40003ca8: 32 bf ff f4 bne,a 40003c78 <IMFS_eval_path_devfs+0xa8>
40003cac: fa 07 40 00 ld [ %i5 ], %i5
if ( entry != NULL ) {
int eval_flags;
eval_flags = rtems_filesystem_eval_path_get_flags( ctx );
if ( ( eval_flags & RTEMS_FS_EXCLUSIVE ) == 0 ) {
40003cb0: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
40003cb4: 80 88 60 40 btst 0x40, %g1
40003cb8: 12 80 00 15 bne 40003d0c <IMFS_eval_path_devfs+0x13c>
40003cbc: 01 00 00 00 nop
--dir->Node.reference_count;
40003cc0: c2 16 60 18 lduh [ %i1 + 0x18 ], %g1
40003cc4: 82 00 7f ff add %g1, -1, %g1
40003cc8: c2 36 60 18 sth %g1, [ %i1 + 0x18 ]
loc->handlers = node->control->handlers;
40003ccc: c4 07 60 38 ld [ %i5 + 0x38 ], %g2
++entry->reference_count;
40003cd0: c2 17 60 18 lduh [ %i5 + 0x18 ], %g1
40003cd4: c4 00 80 00 ld [ %g2 ], %g2
currentloc->node_access = entry;
currentloc->node_access_2 = IMFS_generic_get_context_by_node( entry );
40003cd8: c6 07 60 40 ld [ %i5 + 0x40 ], %g3
++entry->reference_count;
40003cdc: 82 00 60 01 inc %g1
40003ce0: c2 37 60 18 sth %g1, [ %i5 + 0x18 ]
currentloc->node_access = entry;
40003ce4: fa 26 20 20 st %i5, [ %i0 + 0x20 ]
currentloc->node_access_2 = IMFS_generic_get_context_by_node( entry );
40003ce8: c6 26 20 24 st %g3, [ %i0 + 0x24 ]
40003cec: c4 26 20 28 st %g2, [ %i0 + 0x28 ]
ctx->pathlen = 0;
40003cf0: c0 26 20 04 clr [ %i0 + 4 ]
40003cf4: 81 c7 e0 08 ret
40003cf8: 81 e8 00 00 restore
ctx->tokenlen = tokenlen;
40003cfc: f8 26 20 0c st %i4, [ %i0 + 0xc ]
ctx->pathlen = 0;
40003d00: c0 26 20 04 clr [ %i0 + 4 ]
40003d04: 81 c7 e0 08 ret
40003d08: 81 e8 00 00 restore
IMFS_Set_handlers( currentloc );
rtems_filesystem_eval_path_clear_path( ctx );
} else {
rtems_filesystem_eval_path_error( ctx, EEXIST );
40003d0c: 7f ff fc 1d call 40002d80 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
40003d10: 93 e8 20 11 restore %g0, 0x11, %o1
<== NOT EXECUTED
4000b0cc <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
)
{
4000b0cc: 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;
4000b0d0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
4000b0d4: c4 00 60 08 ld [ %g1 + 8 ], %g2
4000b0d8: f6 00 40 00 ld [ %g1 ], %i3
4000b0dc: f8 00 60 04 ld [ %g1 + 4 ], %i4
4000b0e0: c8 00 60 0c ld [ %g1 + 0xc ], %g4
4000b0e4: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
4000b0e8: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
jnode = (IMFS_jnode_t *)loc.node_access;
4000b0ec: ba 10 00 02 mov %g2, %i5
loc = temp_mt_entry->mt_fs_root->location;
4000b0f0: c4 27 bf f0 st %g2, [ %fp + -16 ]
return S_ISDIR( node->st_mode );
4000b0f4: 35 00 00 3c sethi %hi(0xf000), %i2
4000b0f8: c2 27 bf fc st %g1, [ %fp + -4 ]
4000b0fc: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
loc->handlers = node->control->handlers;
4000b100: c4 07 60 38 ld [ %i5 + 0x38 ], %g2
4000b104: c4 00 80 00 ld [ %g2 ], %g2
4000b108: c6 27 bf f8 st %g3, [ %fp + -8 ]
return S_ISDIR( node->st_mode );
4000b10c: 82 08 40 1a and %g1, %i2, %g1
4000b110: 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 ) ) {
4000b114: 37 00 00 10 sethi %hi(0x4000), %i3
loc = temp_mt_entry->mt_fs_root->location;
4000b118: f8 27 bf ec st %i4, [ %fp + -20 ]
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000b11c: 80 a0 40 1b cmp %g1, %i3
next = jnode->Parent;
4000b120: f8 07 60 08 ld [ %i5 + 8 ], %i4
loc = temp_mt_entry->mt_fs_root->location;
4000b124: c8 27 bf f4 st %g4, [ %fp + -12 ]
loc.node_access = (void *)jnode;
4000b128: fa 27 bf f0 st %i5, [ %fp + -16 ]
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000b12c: 12 80 00 14 bne 4000b17c <IMFS_fsunmount+0xb0>
4000b130: c4 27 bf f8 st %g2, [ %fp + -8 ]
return _Chain_Immutable_head( the_chain )->next;
4000b134: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
return &the_chain->Tail.Node;
4000b138: 82 07 60 44 add %i5, 0x44, %g1
4000b13c: 80 a0 80 01 cmp %g2, %g1
4000b140: 02 80 00 10 be 4000b180 <IMFS_fsunmount+0xb4>
4000b144: 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);
4000b148: 80 a0 a0 00 cmp %g2, 0
4000b14c: 02 80 00 23 be 4000b1d8 <IMFS_fsunmount+0x10c>
4000b150: b8 10 00 02 mov %g2, %i4
4000b154: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
4000b158: ba 10 00 1c mov %i4, %i5
loc->handlers = node->control->handlers;
4000b15c: c4 07 60 38 ld [ %i5 + 0x38 ], %g2
4000b160: c4 00 80 00 ld [ %g2 ], %g2
next = jnode->Parent;
4000b164: f8 07 60 08 ld [ %i5 + 8 ], %i4
loc.node_access = (void *)jnode;
4000b168: fa 27 bf f0 st %i5, [ %fp + -16 ]
return S_ISDIR( node->st_mode );
4000b16c: 82 08 40 1a and %g1, %i2, %g1
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
4000b170: 80 a0 40 1b cmp %g1, %i3
4000b174: 02 bf ff f0 be 4000b134 <IMFS_fsunmount+0x68>
4000b178: c4 27 bf f8 st %g2, [ %fp + -8 ]
result = IMFS_rmnod( NULL, &loc );
4000b17c: 92 07 bf e8 add %fp, -24, %o1
4000b180: 7f ff e9 e3 call 4000590c <IMFS_rmnod>
4000b184: 90 10 20 00 clr %o0
if ( result != 0 )
4000b188: 80 a2 20 00 cmp %o0, 0
4000b18c: 12 80 00 15 bne 4000b1e0 <IMFS_fsunmount+0x114>
4000b190: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
IMFS_node_destroy( jnode );
4000b194: 7f ff e9 6b call 40005740 <IMFS_node_destroy>
4000b198: 90 10 00 1d mov %i5, %o0
if ( jnode != NULL ) {
4000b19c: 80 a7 20 00 cmp %i4, 0
4000b1a0: 02 80 00 0e be 4000b1d8 <IMFS_fsunmount+0x10c>
4000b1a4: 01 00 00 00 nop
if ( IMFS_is_directory( jnode ) ) {
4000b1a8: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
4000b1ac: 84 08 40 1a and %g1, %i2, %g2
4000b1b0: 80 a0 80 1b cmp %g2, %i3
4000b1b4: 32 bf ff ea bne,a 4000b15c <IMFS_fsunmount+0x90>
<== NEVER TAKEN
4000b1b8: ba 10 00 1c mov %i4, %i5
<== NOT EXECUTED
4000b1bc: c4 07 20 40 ld [ %i4 + 0x40 ], %g2
if ( jnode_has_children( jnode ) )
4000b1c0: 86 07 20 44 add %i4, 0x44, %g3
4000b1c4: 80 a0 80 03 cmp %g2, %g3
4000b1c8: 12 bf ff e1 bne 4000b14c <IMFS_fsunmount+0x80>
4000b1cc: 80 a0 a0 00 cmp %g2, 0
} while (jnode != NULL);
4000b1d0: 10 bf ff e3 b 4000b15c <IMFS_fsunmount+0x90>
4000b1d4: ba 10 00 1c mov %i4, %i5
}
4000b1d8: 81 c7 e0 08 ret
4000b1dc: 81 e8 00 00 restore
rtems_fatal_error_occurred( 0xdeadbeef );
4000b1e0: 7f ff fa 9e call 40009c58 <rtems_fatal_error_occurred>
<== NOT EXECUTED
4000b1e4: 90 12 22 ef or %o0, 0x2ef, %o0
<== NOT EXECUTED
4000b1e8: 01 00 00 00 nop
<== NOT EXECUTED
400047a0 <IMFS_initialize>:
int IMFS_initialize(
rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data
)
{
400047a0: 9d e3 bf 90 save %sp, -112, %sp
IMFS_fs_info_t *fs_info = calloc( 1, sizeof( *fs_info ) );
400047a4: 92 10 20 58 mov 0x58, %o1
400047a8: 40 00 17 4f call 4000a4e4 <calloc>
400047ac: 90 10 20 01 mov 1, %o0
IMFS_mount_data mount_data = {
400047b0: 03 10 00 3c sethi %hi(0x4000f000), %g1
400047b4: 82 10 61 c0 or %g1, 0x1c0, %g1 ! 4000f1c0 <IMFS_ops>
400047b8: 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 ) {
400047bc: 80 a2 20 00 cmp %o0, 0
IMFS_mount_data mount_data = {
400047c0: c2 27 bf f8 st %g1, [ %fp + -8 ]
400047c4: 03 10 00 3c sethi %hi(0x4000f000), %g1
400047c8: 82 10 61 b0 or %g1, 0x1b0, %g1 ! 4000f1b0 <IMFS_default_mknod_controls>
if ( fs_info == NULL ) {
400047cc: 02 80 00 07 be 400047e8 <IMFS_initialize+0x48>
400047d0: c2 27 bf fc st %g1, [ %fp + -4 ]
rtems_set_errno_and_return_minus_one( ENOMEM );
}
return IMFS_initialize_support( mt_entry, &mount_data );
400047d4: 92 07 bf f4 add %fp, -12, %o1
400047d8: 40 00 00 11 call 4000481c <IMFS_initialize_support>
400047dc: 90 10 00 18 mov %i0, %o0
}
400047e0: 81 c7 e0 08 ret
<== NOT EXECUTED
400047e4: 91 e8 00 08 restore %g0, %o0, %o0
rtems_set_errno_and_return_minus_one( ENOMEM );
400047e8: 40 00 26 22 call 4000e070 <__errno>
400047ec: b0 10 3f ff mov -1, %i0
400047f0: 82 10 20 0c mov 0xc, %g1
400047f4: c2 22 00 00 st %g1, [ %o0 ]
400047f8: 81 c7 e0 08 ret
400047fc: 81 e8 00 00 restore
40006070 <IMFS_initialize_node>:
const char *name,
size_t namelen,
mode_t mode,
void *arg
)
{
40006070: 9d e3 bf 90 save %sp, -112, %sp
time_t now;
if ( namelen > IMFS_NAME_MAX ) {
40006074: 80 a6 e0 ff cmp %i3, 0xff
40006078: 18 80 00 18 bgu 400060d8 <IMFS_initialize_node+0x68>
4000607c: 03 00 00 40 sethi %hi(0x10000), %g1
}
/*
* Fill in the basic information
*/
node->name = name;
40006080: f4 26 20 0c st %i2, [ %i0 + 0xc ]
node->namelen = namelen;
40006084: f6 36 20 10 sth %i3, [ %i0 + 0x10 ]
node->reference_count = 1;
40006088: 82 10 60 01 or %g1, 1, %g1
node->st_nlink = 1;
node->control = node_control;
4000608c: f2 26 20 38 st %i1, [ %i0 + 0x38 ]
node->reference_count = 1;
40006090: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
/*
* Fill in the mode and permission information for the jnode structure.
*/
node->st_mode = mode;
node->st_uid = geteuid();
40006094: 40 00 16 8a call 4000babc <geteuid>
40006098: f8 26 20 14 st %i4, [ %i0 + 0x14 ]
node->st_gid = getegid();
4000609c: 40 00 16 82 call 4000baa4 <getegid>
400060a0: d0 36 20 1c sth %o0, [ %i0 + 0x1c ]
400060a4: d0 36 20 1e sth %o0, [ %i0 + 0x1e ]
_Timecounter_Getbintime( &now );
400060a8: 40 00 13 69 call 4000ae4c <_Timecounter_Getbintime>
400060ac: 90 07 bf f0 add %fp, -16, %o0
return now.sec;
400060b0: c4 1f bf f0 ldd [ %fp + -16 ], %g2
/*
* Now set all the times.
*/
now = _IMFS_get_time();
node->stat_atime = now;
400060b4: c4 3e 20 20 std %g2, [ %i0 + 0x20 ]
node->stat_mtime = now;
node->stat_ctime = now;
return (*node_control->node_initialize)( node, arg );
400060b8: 92 10 00 1d mov %i5, %o1
node->stat_mtime = now;
400060bc: c4 3e 20 28 std %g2, [ %i0 + 0x28 ]
node->stat_ctime = now;
400060c0: c4 3e 20 30 std %g2, [ %i0 + 0x30 ]
return (*node_control->node_initialize)( node, arg );
400060c4: c2 06 60 04 ld [ %i1 + 4 ], %g1
400060c8: 9f c0 40 00 call %g1
400060cc: 90 10 00 18 mov %i0, %o0
}
400060d0: 81 c7 e0 08 ret
400060d4: 91 e8 00 08 restore %g0, %o0, %o0
errno = ENAMETOOLONG;
400060d8: 40 00 24 ba call 4000f3c0 <__errno>
400060dc: b0 10 20 00 clr %i0
<== NOT EXECUTED
400060e0: 82 10 20 5b mov 0x5b, %g1
<== NOT EXECUTED
400060e4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return NULL;
400060e8: 81 c7 e0 08 ret
<== NOT EXECUTED
400060ec: 81 e8 00 00 restore
<== NOT EXECUTED
40005328 <IMFS_initialize_support>:
{
40005328: 9d e3 bf a0 save %sp, -96, %sp
fs_info->mknod_controls = mount_data->mknod_controls;
4000532c: c2 06 60 08 ld [ %i1 + 8 ], %g1
fs_info = mount_data->fs_info;
40005330: d0 06 40 00 ld [ %i1 ], %o0
node_control = &mount_data->mknod_controls->directory->node_control;
40005334: d2 00 40 00 ld [ %g1 ], %o1
fs_info->mknod_controls = mount_data->mknod_controls;
40005338: c2 22 20 50 st %g1, [ %o0 + 0x50 ]
root_node = IMFS_initialize_node(
4000533c: 9a 10 20 00 clr %o5
mt_entry->ops = mount_data->ops;
40005340: c2 06 60 04 ld [ %i1 + 4 ], %g1
40005344: c2 26 20 0c st %g1, [ %i0 + 0xc ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
40005348: 03 10 00 5d sethi %hi(0x40017400), %g1
4000534c: 82 10 63 04 or %g1, 0x304, %g1 ! 40017704 <IMFS_LIMITS_AND_OPTIONS>
mt_entry->mt_fs_root->location.node_access = root_node;
40005350: c4 06 20 24 ld [ %i0 + 0x24 ], %g2
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
40005354: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
root_node = IMFS_initialize_node(
40005358: 19 00 00 10 sethi %hi(0x4000), %o4
mt_entry->fs_info = fs_info;
4000535c: d0 26 20 08 st %o0, [ %i0 + 8 ]
root_node = IMFS_initialize_node(
40005360: 98 13 21 ed or %o4, 0x1ed, %o4
mt_entry->mt_fs_root->location.handlers = node_control->handlers;
40005364: c2 02 40 00 ld [ %o1 ], %g1
40005368: c2 20 a0 10 st %g1, [ %g2 + 0x10 ]
}
4000536c: b0 10 20 00 clr %i0
mt_entry->mt_fs_root->location.node_access = root_node;
40005370: d0 20 a0 08 st %o0, [ %g2 + 8 ]
root_node = IMFS_initialize_node(
40005374: 96 10 20 00 clr %o3
40005378: 15 10 00 5b sethi %hi(0x40016c00), %o2
4000537c: 40 00 03 3d call 40006070 <IMFS_initialize_node>
40005380: 94 12 a1 e8 or %o2, 0x1e8, %o2 ! 40016de8 <rtems_test_name+0x1b0>
}
40005384: 81 c7 e0 08 ret
40005388: 81 e8 00 00 restore
40005478 <IMFS_link>:
{
40005478: 9d e3 bf 88 save %sp, -120, %sp
target = targetloc->node_access;
4000547c: fa 06 60 08 ld [ %i1 + 8 ], %i5
if ( target->st_nlink >= LINK_MAX )
40005480: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
40005484: 80 a0 60 07 cmp %g1, 7
40005488: 18 80 00 19 bgu 400054ec <IMFS_link+0x74>
4000548c: 9a 10 21 ff mov 0x1ff, %o5
new_node = IMFS_create_node(
40005490: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
40005494: 98 10 00 1b mov %i3, %o4
40005498: 96 10 00 1a mov %i2, %o3
4000549c: 94 10 20 48 mov 0x48, %o2
400054a0: 90 10 00 18 mov %i0, %o0
400054a4: 13 10 00 5d sethi %hi(0x40017400), %o1
400054a8: 40 00 1b 6e call 4000c260 <IMFS_create_node>
400054ac: 92 12 61 6c or %o1, 0x16c, %o1 ! 4001756c <IMFS_node_control_hard_link>
if ( !new_node )
400054b0: 80 a2 20 00 cmp %o0, 0
400054b4: 02 80 00 14 be 40005504 <IMFS_link+0x8c>
400054b8: 90 07 bf f0 add %fp, -16, %o0
target->reference_count++;
400054bc: c4 17 60 18 lduh [ %i5 + 0x18 ], %g2
target->st_nlink++;
400054c0: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
target->reference_count++;
400054c4: 84 00 a0 01 inc %g2
target->st_nlink++;
400054c8: 82 00 60 01 inc %g1
target->reference_count++;
400054cc: c4 37 60 18 sth %g2, [ %i5 + 0x18 ]
target->st_nlink++;
400054d0: c2 37 60 1a sth %g1, [ %i5 + 0x1a ]
_Timecounter_Getbintime( &now );
400054d4: 40 00 16 5e call 4000ae4c <_Timecounter_Getbintime>
400054d8: b0 10 20 00 clr %i0
return now.sec;
400054dc: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_ctime = _IMFS_get_time();
400054e0: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
<== NOT EXECUTED
}
400054e4: 81 c7 e0 08 ret
<== NOT EXECUTED
400054e8: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EMLINK );
400054ec: 40 00 27 b5 call 4000f3c0 <__errno>
400054f0: b0 10 3f ff mov -1, %i0
400054f4: 82 10 20 1f mov 0x1f, %g1
400054f8: c2 22 00 00 st %g1, [ %o0 ]
400054fc: 81 c7 e0 08 ret
40005500: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( ENOMEM );
40005504: 40 00 27 af call 4000f3c0 <__errno>
40005508: b0 10 3f ff mov -1, %i0
4000550c: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40005510: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40005514: 81 c7 e0 08 ret
<== NOT EXECUTED
40005518: 81 e8 00 00 restore
40004cf8 <IMFS_make_linearfile>:
const char *path,
mode_t mode,
const void *data,
size_t size
)
{
40004cf8: 9d e3 bf 98 save %sp, -104, %sp
.size = size
};
return IMFS_make_node(
path,
( mode & ~S_IFMT ) | S_IFREG,
40004cfc: 13 00 00 3c sethi %hi(0xf000), %o1
IMFS_linearfile_context ctx = {
40004d00: f4 3f bf f8 std %i2, [ %fp + -8 ]
( mode & ~S_IFMT ) | S_IFREG,
40004d04: b2 2e 40 09 andn %i1, %o1, %i1
return IMFS_make_node(
40004d08: 98 07 bf f8 add %fp, -8, %o4
40004d0c: 96 10 20 58 mov 0x58, %o3
40004d10: 90 10 00 18 mov %i0, %o0
40004d14: 13 00 00 20 sethi %hi(0x8000), %o1
40004d18: 15 10 00 ab sethi %hi(0x4002ac00), %o2
40004d1c: 92 16 40 09 or %i1, %o1, %o1
40004d20: 40 00 35 d0 call 40012460 <IMFS_make_node>
40004d24: 94 12 a1 e8 or %o2, 0x1e8, %o2
&IMFS_node_control_linfile,
sizeof( IMFS_file_t ),
&ctx
);
}
40004d28: 81 c7 e0 08 ret
<== NOT EXECUTED
40004d2c: 91 e8 00 08 restore %g0, %o0, %o0
40007a08 <IMFS_make_node>:
mode_t mode,
const IMFS_node_control *node_control,
size_t node_size,
void *context
)
{
40007a08: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
40007a0c: 7f ff fc e6 call 40006da4 <rtems_current_user_env_get>
40007a10: 01 00 00 00 nop
40007a14: da 02 20 08 ld [ %o0 + 8 ], %o5
40007a18: b2 2e 40 0d andn %i1, %o5, %i1
switch (mode & S_IFMT) {
40007a1c: 03 00 00 3c sethi %hi(0xf000), %g1
40007a20: 05 00 00 18 sethi %hi(0x6000), %g2
40007a24: 82 0e 40 01 and %i1, %g1, %g1
40007a28: 80 a0 40 02 cmp %g1, %g2
40007a2c: 02 80 00 0c be 40007a5c <IMFS_make_node+0x54>
40007a30: 94 10 20 78 mov 0x78, %o2
40007a34: 08 80 00 1d bleu 40007aa8 <IMFS_make_node+0xa0>
40007a38: 05 00 00 04 sethi %hi(0x1000), %g2
40007a3c: 05 00 00 20 sethi %hi(0x8000), %g2
40007a40: 80 a0 40 02 cmp %g1, %g2
40007a44: 02 80 00 06 be 40007a5c <IMFS_make_node+0x54>
40007a48: 05 00 00 30 sethi %hi(0xc000), %g2
40007a4c: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40007a50: 12 80 00 1c bne 40007ac0 <IMFS_make_node+0xb8>
<== NOT EXECUTED
40007a54: 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 =
40007a58: 94 10 20 78 mov 0x78, %o2 ! 78 <_TLS_Alignment+0x77>
<== NOT EXECUTED
40007a5c: 92 10 00 18 mov %i0, %o1
40007a60: 7f ff fa 9f call 400064dc <rtems_filesystem_eval_path_start>
40007a64: 90 07 bf c8 add %fp, -56, %o0
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
40007a68: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40007a6c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
40007a70: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
40007a74: 03 10 00 21 sethi %hi(0x40008400), %g1
40007a78: 82 10 63 18 or %g1, 0x318, %g1 ! 40008718 <IMFS_node_clone>
40007a7c: 80 a0 80 01 cmp %g2, %g1
40007a80: 02 80 00 16 be 40007ad8 <IMFS_make_node+0xd0>
40007a84: ba 10 00 08 mov %o0, %i5
IMFS_mtime_ctime_update( parent );
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
40007a88: 92 10 20 86 mov 0x86, %o1
40007a8c: 90 07 bf c8 add %fp, -56, %o0
40007a90: 7f ff f9 d8 call 400061f0 <rtems_filesystem_eval_path_error>
40007a94: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40007a98: 7f ff fa db call 40006604 <rtems_filesystem_eval_path_cleanup>
40007a9c: 90 07 bf c8 add %fp, -56, %o0
}
return rv;
}
40007aa0: 81 c7 e0 08 ret
40007aa4: 81 e8 00 00 restore
switch (mode & S_IFMT) {
40007aa8: 80 a0 40 02 cmp %g1, %g2
40007aac: 02 bf ff eb be 40007a58 <IMFS_make_node+0x50>
40007ab0: 05 00 00 08 sethi %hi(0x2000), %g2
40007ab4: 80 a0 40 02 cmp %g1, %g2
40007ab8: 02 bf ff e9 be 40007a5c <IMFS_make_node+0x54>
40007abc: 94 10 20 78 mov 0x78, %o2
errno = EINVAL;
40007ac0: 40 00 33 85 call 400148d4 <__errno>
40007ac4: b0 10 3f ff mov -1, %i0
40007ac8: 82 10 20 16 mov 0x16, %g1
40007acc: c2 22 00 00 st %g1, [ %o0 ]
40007ad0: 81 c7 e0 08 ret
40007ad4: 81 e8 00 00 restore
IMFS_jnode_t *new_node = IMFS_create_node(
40007ad8: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
40007adc: 9a 10 00 19 mov %i1, %o5
40007ae0: d8 07 bf d4 ld [ %fp + -44 ], %o4
40007ae4: d6 07 bf d0 ld [ %fp + -48 ], %o3
40007ae8: 94 10 00 1b mov %i3, %o2
40007aec: 92 10 00 1a mov %i2, %o1
40007af0: 40 00 27 ba call 400119d8 <IMFS_create_node>
40007af4: b0 10 3f ff mov -1, %i0
if ( new_node != NULL ) {
40007af8: 80 a2 20 00 cmp %o0, 0
40007afc: 02 bf ff e7 be 40007a98 <IMFS_make_node+0x90>
40007b00: 01 00 00 00 nop
IMFS_jnode_t *parent = currentloc->node_access;
40007b04: fa 07 60 08 ld [ %i5 + 8 ], %i5
_Timecounter_Getbintime( &now );
40007b08: 40 00 17 78 call 4000d8e8 <_Timecounter_Getbintime>
40007b0c: 90 07 bf b8 add %fp, -72, %o0
return now.sec;
40007b10: c4 1f bf b8 ldd [ %fp + -72 ], %g2
jnode->stat_mtime = now;
40007b14: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
int rv = 0;
40007b18: b0 10 20 00 clr %i0
jnode->stat_ctime = now;
40007b1c: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
rtems_filesystem_eval_path_cleanup( &ctx );
40007b20: 7f ff fa b9 call 40006604 <rtems_filesystem_eval_path_cleanup>
40007b24: 90 07 bf c8 add %fp, -56, %o0
}
40007b28: 81 c7 e0 08 ret
<== NOT EXECUTED
40007b2c: 81 e8 00 00 restore
40005cfc <IMFS_memfile_write>:
{
40005cfc: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
if ( last_byte > memfile->File.size ) {
40005d00: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
<== NOT EXECUTED
last_byte = start + my_length;
40005d04: 96 07 00 1a add %i4, %i2, %o3
<== NOT EXECUTED
if ( last_byte > memfile->File.size ) {
40005d08: 80 a0 40 0b cmp %g1, %o3
<== NOT EXECUTED
40005d0c: 0a 80 00 52 bcs 40005e54 <IMFS_memfile_write+0x158>
<== NOT EXECUTED
40005d10: a0 10 00 18 mov %i0, %l0
<== NOT EXECUTED
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
40005d14: 03 10 00 5a sethi %hi(0x40016800), %g1
<== NOT EXECUTED
40005d18: fa 00 63 98 ld [ %g1 + 0x398 ], %i5 ! 40016b98 <imfs_memfile_bytes_per_block>
<== NOT EXECUTED
40005d1c: b1 3f 60 1f sra %i5, 0x1f, %i0
<== NOT EXECUTED
40005d20: 96 10 00 1d mov %i5, %o3
<== NOT EXECUTED
40005d24: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
40005d28: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
40005d2c: 40 00 23 53 call 4000ea78 <__moddi3>
<== NOT EXECUTED
40005d30: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40005d34: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
40005d38: a2 10 00 09 mov %o1, %l1
<== NOT EXECUTED
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40005d3c: 96 10 00 1d mov %i5, %o3
<== NOT EXECUTED
40005d40: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
40005d44: 40 00 22 c2 call 4000e84c <__divdi3>
<== NOT EXECUTED
40005d48: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
copied = 0;
40005d4c: b0 10 20 00 clr %i0
<== NOT EXECUTED
if ( start_offset ) {
40005d50: 80 a4 60 00 cmp %l1, 0
<== NOT EXECUTED
40005d54: 12 80 00 19 bne 40005db8 <IMFS_memfile_write+0xbc>
<== NOT EXECUTED
40005d58: b4 10 00 09 mov %o1, %i2
<== NOT EXECUTED
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40005d5c: 80 a7 00 1d cmp %i4, %i5
<== NOT EXECUTED
40005d60: 1a 80 00 0d bcc 40005d94 <IMFS_memfile_write+0x98>
<== NOT EXECUTED
40005d64: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
if ( my_length ) {
40005d68: 10 80 00 28 b 40005e08 <IMFS_memfile_write+0x10c>
<== NOT EXECUTED
40005d6c: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
40005d70: 40 00 26 4f call 4000f6ac <memcpy>
<== NOT EXECUTED
40005d74: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
my_length -= to_copy;
40005d78: b8 27 00 1d sub %i4, %i5, %i4
<== NOT EXECUTED
src += to_copy;
40005d7c: b6 06 c0 1d add %i3, %i5, %i3
<== NOT EXECUTED
block++;
40005d80: b4 06 a0 01 inc %i2
<== NOT EXECUTED
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40005d84: 80 a7 40 1c cmp %i5, %i4
<== NOT EXECUTED
40005d88: 18 80 00 1f bgu 40005e04 <IMFS_memfile_write+0x108>
<== NOT EXECUTED
40005d8c: b0 06 00 1d add %i0, %i5, %i0
<== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40005d90: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
40005d94: 94 10 20 00 clr %o2
<== NOT EXECUTED
40005d98: 7f ff fd ee call 40005550 <IMFS_memfile_get_block_pointer>
<== NOT EXECUTED
40005d9c: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
40005da0: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
if ( !block_ptr )
40005da4: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005da8: 12 bf ff f2 bne 40005d70 <IMFS_memfile_write+0x74>
<== NOT EXECUTED
40005dac: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
}
40005db0: 81 c7 e0 08 ret
<== NOT EXECUTED
40005db4: 81 e8 00 00 restore
<== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40005db8: 94 10 20 00 clr %o2
<== NOT EXECUTED
40005dbc: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
40005dc0: 7f ff fd e4 call 40005550 <IMFS_memfile_get_block_pointer>
<== NOT EXECUTED
40005dc4: b0 10 20 00 clr %i0
<== NOT EXECUTED
if ( !block_ptr )
40005dc8: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005dcc: 02 bf ff f9 be 40005db0 <IMFS_memfile_write+0xb4>
<== NOT EXECUTED
40005dd0: 82 27 40 11 sub %i5, %l1, %g1
<== NOT EXECUTED
40005dd4: 80 a7 00 01 cmp %i4, %g1
<== NOT EXECUTED
40005dd8: 18 80 00 36 bgu 40005eb0 <IMFS_memfile_write+0x1b4>
<== NOT EXECUTED
40005ddc: b0 10 00 1c mov %i4, %i0
<== NOT EXECUTED
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
40005de0: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
40005de4: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
40005de8: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
40005dec: 90 02 00 11 add %o0, %l1, %o0
<== NOT EXECUTED
40005df0: 40 00 26 2f call 4000f6ac <memcpy>
<== NOT EXECUTED
40005df4: b6 06 c0 18 add %i3, %i0, %i3
<== NOT EXECUTED
block++;
40005df8: b4 06 a0 01 inc %i2
<== NOT EXECUTED
my_length -= to_copy;
40005dfc: 10 bf ff d8 b 40005d5c <IMFS_memfile_write+0x60>
<== NOT EXECUTED
40005e00: b8 27 00 18 sub %i4, %i0, %i4
<== NOT EXECUTED
if ( my_length ) {
40005e04: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
40005e08: 02 80 00 0c be 40005e38 <IMFS_memfile_write+0x13c>
<== NOT EXECUTED
40005e0c: 94 10 20 00 clr %o2
<== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40005e10: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
40005e14: 7f ff fd cf call 40005550 <IMFS_memfile_get_block_pointer>
<== NOT EXECUTED
40005e18: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
if ( !block_ptr )
40005e1c: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40005e20: 02 bf ff e4 be 40005db0 <IMFS_memfile_write+0xb4>
<== NOT EXECUTED
40005e24: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
memcpy( &(*block_ptr)[ 0 ], src, my_length );
40005e28: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
40005e2c: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
40005e30: 40 00 26 1f call 4000f6ac <memcpy>
<== NOT EXECUTED
40005e34: b0 06 00 1c add %i0, %i4, %i0
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
40005e38: 40 00 14 05 call 4000ae4c <_Timecounter_Getbintime>
<== NOT EXECUTED
40005e3c: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
return now.sec;
40005e40: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_mtime = now;
40005e44: c4 3c 20 28 std %g2, [ %l0 + 0x28 ]
<== NOT EXECUTED
jnode->stat_ctime = now;
40005e48: c4 3c 20 30 std %g2, [ %l0 + 0x30 ]
<== NOT EXECUTED
}
40005e4c: 81 c7 e0 08 ret
<== NOT EXECUTED
40005e50: 81 e8 00 00 restore
<== NOT EXECUTED
bool zero_fill = start > memfile->File.size;
40005e54: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40005e58: 04 80 00 0b ble 40005e84 <IMFS_memfile_write+0x188>
<== NOT EXECUTED
40005e5c: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
40005e60: 94 10 20 00 clr %o2
<== NOT EXECUTED
40005e64: 92 0a 60 01 and %o1, 1, %o1
<== NOT EXECUTED
40005e68: 7f ff fe 63 call 400057f4 <IMFS_memfile_extend>
<== NOT EXECUTED
40005e6c: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
if ( status )
40005e70: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
40005e74: 02 bf ff a9 be 40005d18 <IMFS_memfile_write+0x1c>
<== NOT EXECUTED
40005e78: 03 10 00 5a sethi %hi(0x40016800), %g1
<== NOT EXECUTED
40005e7c: 81 c7 e0 08 ret
<== NOT EXECUTED
40005e80: 81 e8 00 00 restore
<== NOT EXECUTED
bool zero_fill = start > memfile->File.size;
40005e84: 02 80 00 15 be 40005ed8 <IMFS_memfile_write+0x1dc>
<== NOT EXECUTED
40005e88: 80 a6 80 01 cmp %i2, %g1
<== NOT EXECUTED
40005e8c: 92 10 20 00 clr %o1
<== NOT EXECUTED
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
40005e90: 94 10 20 00 clr %o2
<== NOT EXECUTED
40005e94: 92 0a 60 01 and %o1, 1, %o1
<== NOT EXECUTED
40005e98: 7f ff fe 57 call 400057f4 <IMFS_memfile_extend>
<== NOT EXECUTED
40005e9c: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
if ( status )
40005ea0: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
40005ea4: 02 bf ff 9d be 40005d18 <IMFS_memfile_write+0x1c>
<== NOT EXECUTED
40005ea8: 03 10 00 5a sethi %hi(0x40016800), %g1
<== NOT EXECUTED
40005eac: 30 bf ff f4 b,a 40005e7c <IMFS_memfile_write+0x180>
<== NOT EXECUTED
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
40005eb0: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
40005eb4: b0 10 00 01 mov %g1, %i0
<== NOT EXECUTED
40005eb8: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
40005ebc: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
40005ec0: 90 02 00 11 add %o0, %l1, %o0
<== NOT EXECUTED
40005ec4: 40 00 25 fa call 4000f6ac <memcpy>
<== NOT EXECUTED
40005ec8: b6 06 c0 18 add %i3, %i0, %i3
<== NOT EXECUTED
block++;
40005ecc: b4 06 a0 01 inc %i2
<== NOT EXECUTED
my_length -= to_copy;
40005ed0: 10 bf ff a3 b 40005d5c <IMFS_memfile_write+0x60>
<== NOT EXECUTED
40005ed4: b8 27 00 18 sub %i4, %i0, %i4
<== NOT EXECUTED
bool zero_fill = start > memfile->File.size;
40005ed8: 18 bf ff e3 bgu 40005e64 <IMFS_memfile_write+0x168>
<== NOT EXECUTED
40005edc: 94 10 20 00 clr %o2
<== NOT EXECUTED
40005ee0: 10 bf ff ed b 40005e94 <IMFS_memfile_write+0x198>
<== NOT EXECUTED
40005ee4: 92 10 20 00 clr %o1
<== NOT EXECUTED
40005f4c <IMFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40005f4c: 9d e3 bf 80 save %sp, -128, %sp
int rv = 0;
const IMFS_fs_info_t *fs_info = parentloc->mt_entry->fs_info;
40005f50: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
{
40005f54: f8 3f bf e8 std %i4, [ %fp + -24 ]
const IMFS_mknod_control *mknod_control =
get_control( fs_info->mknod_controls, mode );
40005f58: c4 00 60 08 ld [ %g1 + 8 ], %g2
40005f5c: c6 00 a0 50 ld [ %g2 + 0x50 ], %g3
if ( S_ISDIR( mode ) ) {
40005f60: 03 00 00 3c sethi %hi(0xf000), %g1
40005f64: 05 00 00 10 sethi %hi(0x4000), %g2
40005f68: 82 0e c0 01 and %i3, %g1, %g1
40005f6c: 80 a0 40 02 cmp %g1, %g2
40005f70: 02 80 00 1f be 40005fec <IMFS_mknod+0xa0>
40005f74: 05 00 00 2c sethi %hi(0xb000), %g2
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
40005f78: 09 00 00 08 sethi %hi(0x2000), %g4
40005f7c: 84 0e c0 02 and %i3, %g2, %g2
40005f80: 80 a0 80 04 cmp %g2, %g4
40005f84: 22 80 00 07 be,a 40005fa0 <IMFS_mknod+0x54>
40005f88: d2 00 e0 04 ld [ %g3 + 4 ], %o1
} else if ( S_ISFIFO( mode ) ) {
40005f8c: 05 00 00 04 sethi %hi(0x1000), %g2
40005f90: 80 a0 40 02 cmp %g1, %g2
40005f94: 22 80 00 03 be,a 40005fa0 <IMFS_mknod+0x54>
40005f98: d2 00 e0 0c ld [ %g3 + 0xc ], %o1
return controls->file;
40005f9c: d2 00 e0 08 ld [ %g3 + 8 ], %o1
IMFS_jnode_t *new_node;
new_node = IMFS_create_node(
40005fa0: 82 07 bf e8 add %fp, -24, %g1
40005fa4: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40005fa8: 9a 10 00 1b mov %i3, %o5
40005fac: d4 02 60 10 ld [ %o1 + 0x10 ], %o2
40005fb0: 98 10 00 1a mov %i2, %o4
40005fb4: 96 10 00 19 mov %i1, %o3
40005fb8: 40 00 18 aa call 4000c260 <IMFS_create_node>
40005fbc: 90 10 00 18 mov %i0, %o0
name,
namelen,
mode,
&dev
);
if ( new_node != NULL ) {
40005fc0: 80 a2 20 00 cmp %o0, 0
40005fc4: 02 80 00 0c be 40005ff4 <IMFS_mknod+0xa8>
<== NEVER TAKEN
40005fc8: 01 00 00 00 nop
IMFS_jnode_t *parent = parentloc->node_access;
40005fcc: fa 06 20 08 ld [ %i0 + 8 ], %i5
_Timecounter_Getbintime( &now );
40005fd0: 40 00 13 9f call 4000ae4c <_Timecounter_Getbintime>
40005fd4: 90 07 bf f0 add %fp, -16, %o0
return now.sec;
40005fd8: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_mtime = now;
40005fdc: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
jnode->stat_ctime = now;
40005fe0: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
int rv = 0;
40005fe4: 81 c7 e0 08 ret
40005fe8: 91 e8 20 00 restore %g0, 0, %o0
return controls->directory;
40005fec: 10 bf ff ed b 40005fa0 <IMFS_mknod+0x54>
40005ff0: d2 00 c0 00 ld [ %g3 ], %o1
} else {
rv = -1;
}
return rv;
}
40005ff4: 81 c7 e0 08 ret
<== NOT EXECUTED
40005ff8: 91 e8 3f ff restore %g0, -1, %o0
40005ffc <IMFS_mount>:
#endif
#include <rtems/imfs.h>
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40005ffc: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40006000: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40006004: c4 00 60 08 ld [ %g1 + 8 ], %g2
return S_ISDIR( node->st_mode );
40006008: 07 00 00 3c sethi %hi(0xf000), %g3
4000600c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
40006010: 82 08 40 03 and %g1, %g3, %g1
if ( IMFS_is_directory( node ) ) {
40006014: 07 00 00 10 sethi %hi(0x4000), %g3
40006018: 80 a0 40 03 cmp %g1, %g3
4000601c: 12 80 00 0f bne 40006058 <IMFS_mount+0x5c>
<== NEVER TAKEN
40006020: 01 00 00 00 nop
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == NULL ) {
40006024: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
40006028: 80 a0 60 00 cmp %g1, 0
4000602c: 12 80 00 05 bne 40006040 <IMFS_mount+0x44>
40006030: 01 00 00 00 nop
dir->mt_fs = mt_entry;
40006034: f0 20 a0 4c st %i0, [ %g2 + 0x4c ]
40006038: 81 c7 e0 08 ret
4000603c: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = EBUSY;
40006040: 40 00 24 e0 call 4000f3c0 <__errno>
<== NOT EXECUTED
40006044: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006048: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
4000604c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006050: 81 c7 e0 08 ret
<== NOT EXECUTED
40006054: 81 e8 00 00 restore
<== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40006058: 40 00 24 da call 4000f3c0 <__errno>
4000605c: b0 10 3f ff mov -1, %i0
40006060: 82 10 20 14 mov 0x14, %g1
40006064: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
40006068: 81 c7 e0 08 ret
4000606c: 81 e8 00 00 restore
40006108 <IMFS_node_destroy>:
void IMFS_node_destroy( IMFS_jnode_t *node )
{
40006108: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
IMFS_assert( node->reference_count == 0 );
(*node->control->node_destroy)( node );
4000610c: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
<== NOT EXECUTED
40006110: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
40006114: 9f c0 40 00 call %g1
<== NOT EXECUTED
40006118: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
4000611c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006120: 81 e8 00 00 restore
<== NOT EXECUTED
40006170 <IMFS_node_destroy_default>:
#include <stdlib.h>
void IMFS_node_destroy_default( IMFS_jnode_t *node )
{
free( node );
40006170: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40006174: 7f ff f4 d2 call 400034bc <free>
<== NOT EXECUTED
40006178: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
40006124 <IMFS_node_free>:
void IMFS_node_free( const rtems_filesystem_location_info_t *loc )
{
40006124: 9d e3 bf a0 save %sp, -96, %sp
IMFS_jnode_t *node = loc->node_access;
40006128: d0 06 20 08 ld [ %i0 + 8 ], %o0
--node->reference_count;
4000612c: c2 12 20 18 lduh [ %o0 + 0x18 ], %g1
40006130: 82 00 7f ff add %g1, -1, %g1
40006134: c2 32 20 18 sth %g1, [ %o0 + 0x18 ]
if ( node->reference_count == 0 ) {
40006138: 83 28 60 10 sll %g1, 0x10, %g1
4000613c: 80 a0 60 00 cmp %g1, 0
40006140: 12 80 00 06 bne 40006158 <IMFS_node_free+0x34>
<== ALWAYS TAKEN
40006144: 01 00 00 00 nop
(*node->control->node_destroy)( node );
40006148: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
4000614c: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40006150: 9f c0 40 00 call %g1
40006154: 01 00 00 00 nop
IMFS_node_destroy( node );
}
}
40006158: 81 c7 e0 08 ret
4000615c: 81 e8 00 00 restore
4000c314 <IMFS_node_remove_directory>:
{
return dir->mt_fs != NULL;
}
IMFS_jnode_t *IMFS_node_remove_directory( IMFS_jnode_t *node )
{
4000c314: 9d e3 bf a0 save %sp, -96, %sp
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( !rtems_chain_is_empty( &dir->Entries ) ) {
4000c318: c4 06 20 40 ld [ %i0 + 0x40 ], %g2
return &the_chain->Tail.Node;
4000c31c: 82 06 20 44 add %i0, 0x44, %g1
4000c320: 80 a0 80 01 cmp %g2, %g1
4000c324: 12 80 00 0c bne 4000c354 <IMFS_node_remove_directory+0x40>
4000c328: 01 00 00 00 nop
errno = ENOTEMPTY;
dir = NULL;
} else if ( IMFS_is_mount_point( dir ) ) {
4000c32c: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
4000c330: 80 a0 60 00 cmp %g1, 0
4000c334: 02 80 00 0c be 4000c364 <IMFS_node_remove_directory+0x50>
4000c338: 01 00 00 00 nop
errno = EBUSY;
4000c33c: 40 00 0c 21 call 4000f3c0 <__errno>
<== NOT EXECUTED
4000c340: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
4000c344: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
4000c348: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
dir = NULL;
}
return &dir->Node;
}
4000c34c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000c350: 81 e8 00 00 restore
<== NOT EXECUTED
errno = ENOTEMPTY;
4000c354: 40 00 0c 1b call 4000f3c0 <__errno>
4000c358: b0 10 20 00 clr %i0
4000c35c: 82 10 20 5a mov 0x5a, %g1
4000c360: c2 22 00 00 st %g1, [ %o0 ]
4000c364: 81 c7 e0 08 ret
4000c368: 81 e8 00 00 restore
4000647c <IMFS_readlink>:
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
4000647c: 80 a2 a0 00 cmp %o2, 0
40006480: 02 80 00 16 be 400064d8 <IMFS_readlink+0x5c>
40006484: c6 02 20 08 ld [ %o0 + 8 ], %g3
40006488: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
4000648c: c4 48 40 00 ldsb [ %g1 ], %g2
40006490: 90 10 20 00 clr %o0
40006494: 80 a0 a0 00 cmp %g2, 0
40006498: 12 80 00 07 bne 400064b4 <IMFS_readlink+0x38>
4000649c: c2 08 40 00 ldub [ %g1 ], %g1
400064a0: 30 80 00 0c b,a 400064d0 <IMFS_readlink+0x54>
<== NOT EXECUTED
400064a4: c4 48 40 08 ldsb [ %g1 + %o0 ], %g2
400064a8: 80 a0 a0 00 cmp %g2, 0
400064ac: 02 80 00 07 be 400064c8 <IMFS_readlink+0x4c>
400064b0: c2 08 40 08 ldub [ %g1 + %o0 ], %g1
buf[i] = sym_link->name[i];
400064b4: c2 2a 40 08 stb %g1, [ %o1 + %o0 ]
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
400064b8: 90 02 20 01 inc %o0
400064bc: 80 a2 80 08 cmp %o2, %o0
400064c0: 32 bf ff f9 bne,a 400064a4 <IMFS_readlink+0x28>
400064c4: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
}
400064c8: 81 c3 e0 08 retl
400064cc: 01 00 00 00 nop
400064d0: 81 c3 e0 08 retl
<== NOT EXECUTED
400064d4: 01 00 00 00 nop
<== NOT EXECUTED
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
400064d8: 81 c3 e0 08 retl
<== NOT EXECUTED
400064dc: 90 10 20 00 clr %o0 ! 0 <PROM_START>
<== NOT EXECUTED
400061a8 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
400061a8: 9d e3 bf 90 save %sp, -112, %sp
/*
* FIXME: Due to insufficient checks we can create inaccessible nodes with
* this operation.
*/
node = oldloc->node_access;
400061ac: fa 06 60 08 ld [ %i1 + 8 ], %i5
new_parent = newparentloc->node_access;
if ( node->Parent == NULL ) {
400061b0: c2 07 60 08 ld [ %i5 + 8 ], %g1
400061b4: 80 a0 60 00 cmp %g1, 0
400061b8: 02 80 00 43 be 400062c4 <IMFS_rename+0x11c>
400061bc: f2 06 a0 08 ld [ %i2 + 8 ], %i1
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( namelen >= IMFS_NAME_MAX ) {
400061c0: 80 a7 20 fe cmp %i4, 0xfe
400061c4: 18 80 00 34 bgu 40006294 <IMFS_rename+0xec>
400061c8: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
}
control = malloc( sizeof( *control ) + namelen );
400061cc: 7f ff f4 fa call 400035b4 <malloc>
400061d0: 90 07 20 14 add %i4, 0x14, %o0
if ( control == NULL ) {
400061d4: b4 92 20 00 orcc %o0, 0, %i2
400061d8: 02 80 00 35 be 400062ac <IMFS_rename+0x104>
400061dc: 92 10 00 1b mov %i3, %o1
rtems_set_errno_and_return_minus_one( ENOMEM );
}
memcpy( control->name, name, namelen );
400061e0: b0 06 a0 14 add %i2, 0x14, %i0
400061e4: 94 10 00 1c mov %i4, %o2
400061e8: 40 00 25 31 call 4000f6ac <memcpy>
400061ec: 90 10 00 18 mov %i0, %o0
if ( node->control->node_destroy == IMFS_renamed_destroy ) {
400061f0: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
400061f4: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400061f8: 37 10 00 18 sethi %hi(0x40006000), %i3
400061fc: b6 16 e1 7c or %i3, 0x17c, %i3 ! 4000617c <IMFS_renamed_destroy>
40006200: 80 a0 80 1b cmp %g2, %i3
40006204: 22 80 00 1f be,a 40006280 <IMFS_rename+0xd8>
40006208: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
IMFS_restore_replaced_control( node );
}
control->Base = *node->control;
4000620c: c4 00 40 00 ld [ %g1 ], %g2
40006210: c4 26 80 00 st %g2, [ %i2 ]
40006214: 86 06 60 44 add %i1, 0x44, %g3
40006218: c4 00 60 04 ld [ %g1 + 4 ], %g2
4000621c: c4 26 a0 04 st %g2, [ %i2 + 4 ]
_Timecounter_Getbintime( &now );
40006220: 90 07 bf f0 add %fp, -16, %o0
40006224: c4 00 60 08 ld [ %g1 + 8 ], %g2
40006228: c4 26 a0 08 st %g2, [ %i2 + 8 ]
control->Base.node_destroy = IMFS_renamed_destroy;
control->replaced = node->control;
4000622c: c2 26 a0 10 st %g1, [ %i2 + 0x10 ]
control->Base.node_destroy = IMFS_renamed_destroy;
40006230: f6 26 a0 0c st %i3, [ %i2 + 0xc ]
next = the_node->next;
40006234: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
40006238: c2 07 60 04 ld [ %i5 + 4 ], %g1
node->control = &control->Base;
node->name = control->name;
4000623c: f0 27 60 0c st %i0, [ %i5 + 0xc ]
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
return 0;
40006240: b0 10 20 00 clr %i0
node->control = &control->Base;
40006244: f4 27 60 38 st %i2, [ %i5 + 0x38 ]
node->namelen = namelen;
40006248: f8 37 60 10 sth %i4, [ %i5 + 0x10 ]
next->previous = previous;
4000624c: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40006250: c4 20 40 00 st %g2, [ %g1 ]
old_last = tail->previous;
40006254: c2 06 60 48 ld [ %i1 + 0x48 ], %g1
the_node->next = tail;
40006258: c6 27 40 00 st %g3, [ %i5 ]
entry_node->Parent = dir_node;
4000625c: f2 27 60 08 st %i1, [ %i5 + 8 ]
tail->previous = the_node;
40006260: fa 26 60 48 st %i5, [ %i1 + 0x48 ]
old_last->next = the_node;
40006264: fa 20 40 00 st %i5, [ %g1 ]
_Timecounter_Getbintime( &now );
40006268: 40 00 12 f9 call 4000ae4c <_Timecounter_Getbintime>
4000626c: c2 27 60 04 st %g1, [ %i5 + 4 ]
return now.sec;
40006270: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_ctime = _IMFS_get_time();
40006274: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
}
40006278: 81 c7 e0 08 ret
4000627c: 81 e8 00 00 restore
node->control = control->replaced;
40006280: c4 27 60 38 st %g2, [ %i5 + 0x38 ]
free( control );
40006284: 7f ff f4 8e call 400034bc <free>
40006288: 90 10 00 01 mov %g1, %o0
4000628c: 10 bf ff e0 b 4000620c <IMFS_rename+0x64>
40006290: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
40006294: 40 00 24 4b call 4000f3c0 <__errno>
40006298: b0 10 3f ff mov -1, %i0
4000629c: 82 10 20 5b mov 0x5b, %g1
400062a0: c2 22 00 00 st %g1, [ %o0 ]
400062a4: 81 c7 e0 08 ret
400062a8: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( ENOMEM );
400062ac: 40 00 24 45 call 4000f3c0 <__errno>
<== NOT EXECUTED
400062b0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400062b4: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
400062b8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400062bc: 81 c7 e0 08 ret
<== NOT EXECUTED
400062c0: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
400062c4: 40 00 24 3f call 4000f3c0 <__errno>
<== NOT EXECUTED
400062c8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400062cc: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400062d0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400062d4: 81 c7 e0 08 ret
<== NOT EXECUTED
400062d8: 81 e8 00 00 restore
<== NOT EXECUTED
400062dc <IMFS_rmnod>:
int IMFS_rmnod(
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
400062dc: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = loc->node_access;
400062e0: d0 06 60 08 ld [ %i1 + 8 ], %o0
node = (*node->control->node_remove)( node );
400062e4: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
400062e8: c2 00 60 08 ld [ %g1 + 8 ], %g1
400062ec: 9f c0 40 00 call %g1
400062f0: 01 00 00 00 nop
if ( node != NULL ) {
400062f4: 80 a2 20 00 cmp %o0, 0
400062f8: 22 80 00 11 be,a 4000633c <IMFS_rmnod+0x60>
400062fc: b0 10 3f ff mov -1, %i0
--node->reference_count;
40006300: c4 12 20 18 lduh [ %o0 + 0x18 ], %g2
--node->st_nlink;
40006304: c2 12 20 1a lduh [ %o0 + 0x1a ], %g1
40006308: 82 00 7f ff add %g1, -1, %g1
--node->reference_count;
4000630c: 84 00 bf ff add %g2, -1, %g2
--node->st_nlink;
40006310: c2 32 20 1a sth %g1, [ %o0 + 0x1a ]
--node->reference_count;
40006314: c4 32 20 18 sth %g2, [ %o0 + 0x18 ]
if ( node->Parent != NULL ) {
40006318: c2 02 20 08 ld [ %o0 + 8 ], %g1
4000631c: 80 a0 60 00 cmp %g1, 0
40006320: 02 80 00 07 be 4000633c <IMFS_rmnod+0x60>
40006324: b0 10 20 00 clr %i0
node->Parent = NULL;
40006328: c0 22 20 08 clr [ %o0 + 8 ]
next = the_node->next;
4000632c: c4 02 00 00 ld [ %o0 ], %g2
previous = the_node->previous;
40006330: c2 02 20 04 ld [ %o0 + 4 ], %g1
next->previous = previous;
40006334: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40006338: c4 20 40 00 st %g2, [ %g1 ]
4000633c: 81 c7 e0 08 ret
40006340: 81 e8 00 00 restore
} else {
rv = -1;
}
return rv;
}
40006344: 81 c7 e0 08 ret
<== NOT EXECUTED
40006348: 81 e8 00 00 restore
<== NOT EXECUTED
40006418 <IMFS_symlink>:
{
40006418: 9d e3 bf 98 save %sp, -104, %sp
sizeof( IMFS_sym_link_t ) + strlen( target ) + 1,
4000641c: 40 00 26 10 call 4000fc5c <strlen>
40006420: 90 10 00 1b mov %i3, %o0
new_node = IMFS_create_node(
40006424: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
40006428: 94 02 20 49 add %o0, 0x49, %o2
4000642c: 98 10 00 1a mov %i2, %o4
40006430: 90 10 00 18 mov %i0, %o0
40006434: 1b 00 00 28 sethi %hi(0xa000), %o5
40006438: 96 10 00 19 mov %i1, %o3
4000643c: 9a 13 61 ff or %o5, 0x1ff, %o5
40006440: 13 10 00 5d sethi %hi(0x40017400), %o1
return 0;
40006444: b0 10 20 00 clr %i0
new_node = IMFS_create_node(
40006448: 40 00 17 86 call 4000c260 <IMFS_create_node>
4000644c: 92 12 62 10 or %o1, 0x210, %o1
if ( new_node == NULL ) {
40006450: 80 a2 20 00 cmp %o0, 0
40006454: 02 80 00 04 be 40006464 <IMFS_symlink+0x4c>
40006458: 01 00 00 00 nop
}
4000645c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006460: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( ENOMEM );
40006464: 40 00 23 d7 call 4000f3c0 <__errno>
40006468: b0 10 3f ff mov -1, %i0
4000646c: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40006470: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
40006474: 81 c7 e0 08 ret
<== NOT EXECUTED
40006478: 81 e8 00 00 restore
400064e0 <IMFS_unmount>:
#endif
#include <rtems/imfs.h>
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
400064e0: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
400064e4: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
400064e8: c4 00 60 08 ld [ %g1 + 8 ], %g2
return S_ISDIR( node->st_mode );
400064ec: 07 00 00 3c sethi %hi(0xf000), %g3
400064f0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
400064f4: 82 08 40 03 and %g1, %g3, %g1
if ( IMFS_is_directory( node ) ) {
400064f8: 07 00 00 10 sethi %hi(0x4000), %g3
400064fc: 80 a0 40 03 cmp %g1, %g3
40006500: 12 80 00 0f bne 4000653c <IMFS_unmount+0x5c>
40006504: 01 00 00 00 nop
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == mt_entry ) {
40006508: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
4000650c: 80 a0 40 18 cmp %g1, %i0
40006510: 12 80 00 05 bne 40006524 <IMFS_unmount+0x44>
40006514: 01 00 00 00 nop
dir->mt_fs = NULL;
40006518: c0 20 a0 4c clr [ %g2 + 0x4c ]
4000651c: 81 c7 e0 08 ret
40006520: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = EINVAL;
40006524: 40 00 23 a7 call 4000f3c0 <__errno>
<== NOT EXECUTED
40006528: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000652c: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40006530: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40006534: 81 c7 e0 08 ret
<== NOT EXECUTED
40006538: 81 e8 00 00 restore
<== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
4000653c: 40 00 23 a1 call 4000f3c0 <__errno>
<== NOT EXECUTED
40006540: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40006544: 82 10 20 14 mov 0x14, %g1
<== NOT EXECUTED
40006548: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
4000654c: 81 c7 e0 08 ret
<== NOT EXECUTED
40006550: 81 e8 00 00 restore
<== NOT EXECUTED
4000c258 <device_ftruncate>:
rtems_libio_t *iop,
off_t length
)
{
return 0;
}
4000c258: 81 c3 e0 08 retl
<== NOT EXECUTED
4000c25c: 90 10 20 00 clr %o0
<== NOT EXECUTED
400095c8 <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
400095c8: 9d e3 bf 38 save %sp, -200, %sp
rtems_status_code sc = RTEMS_SUCCESSFUL;
struct stat st;
int rv = stat( name, &st );
400095cc: 90 10 00 18 mov %i0, %o0
{
400095d0: ba 10 00 18 mov %i0, %i5
int rv = stat( name, &st );
400095d4: 92 07 bf 98 add %fp, -104, %o1
400095d8: 40 00 19 9a call 4000fc40 <stat>
400095dc: b0 10 20 0d mov 0xd, %i0
if ( rv == 0 && S_ISCHR( st.st_mode ) ) {
400095e0: 80 a2 20 00 cmp %o0, 0
400095e4: 12 80 00 11 bne 40009628 <rtems_io_lookup_name+0x60>
400095e8: 05 00 00 3c sethi %hi(0xf000), %g2
400095ec: c2 07 bf a8 ld [ %fp + -88 ], %g1
400095f0: 82 08 40 02 and %g1, %g2, %g1
400095f4: 05 00 00 08 sethi %hi(0x2000), %g2
400095f8: 80 a0 40 02 cmp %g1, %g2
400095fc: 12 80 00 0b bne 40009628 <rtems_io_lookup_name+0x60>
40009600: 01 00 00 00 nop
device_info->device_name = name;
40009604: fa 26 40 00 st %i5, [ %i1 ]
device_info->device_name_length = strlen( name );
40009608: 40 00 26 0c call 40012e38 <strlen>
4000960c: 90 10 00 1d mov %i5, %o0
device_info->major = rtems_filesystem_dev_major_t( st.st_rdev );
40009610: c2 07 bf b8 ld [ %fp + -72 ], %g1
<== NOT EXECUTED
40009614: c2 26 60 08 st %g1, [ %i1 + 8 ]
<== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
40009618: b0 10 20 00 clr %i0
<== NOT EXECUTED
device_info->minor = rtems_filesystem_dev_minor_t( st.st_rdev );
4000961c: c2 07 bf bc ld [ %fp + -68 ], %g1
<== NOT EXECUTED
device_info->device_name_length = strlen( name );
40009620: d0 26 60 04 st %o0, [ %i1 + 4 ]
<== NOT EXECUTED
device_info->minor = rtems_filesystem_dev_minor_t( st.st_rdev );
40009624: c2 26 60 0c st %g1, [ %i1 + 0xc ]
<== NOT EXECUTED
} else {
sc = RTEMS_UNSATISFIED;
}
return sc;
}
40009628: 81 c7 e0 08 ret
4000962c: 81 e8 00 00 restore
400079f0 <rtems_io_register_name>:
rtems_status_code rtems_io_register_name(
const char *device_name,
rtems_device_major_number major,
rtems_device_minor_number minor
)
{
400079f0: 9d e3 bf a0 save %sp, -96, %sp
int status;
dev_t dev;
dev = rtems_filesystem_make_dev_t( major, minor );
status = mknod( device_name, 0777 | S_IFCHR, dev );
400079f4: 13 00 00 08 sethi %hi(0x2000), %o1
400079f8: 90 10 00 18 mov %i0, %o0
400079fc: 94 10 00 19 mov %i1, %o2
40007a00: 96 10 00 1a mov %i2, %o3
40007a04: 7f ff f2 f5 call 400045d8 <mknod>
40007a08: 92 12 61 ff or %o1, 0x1ff, %o1
/* this is the only error returned by the old version */
if ( status )
return RTEMS_TOO_MANY;
return RTEMS_SUCCESSFUL;
40007a0c: 80 a0 00 08 cmp %g0, %o0
<== NOT EXECUTED
40007a10: b0 60 20 00 subx %g0, 0, %i0
<== NOT EXECUTED
}
40007a14: b0 0e 20 05 and %i0, 5, %i0
<== NOT EXECUTED
40007a18: 81 c7 e0 08 ret
<== NOT EXECUTED
40007a1c: 81 e8 00 00 restore
40004be8 <rtems_tarfs_load>:
int rtems_tarfs_load(
const char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
40004be8: 9d e3 bd e8 save %sp, -536, %sp
char buf[ 156 + UNTAR_FILE_NAME_SIZE ];
size_t len;
Untar_HeaderContext ctx;
unsigned long ptr;
len = strlen( mountpoint );
40004bec: 40 00 70 99 call 40020e50 <strlen>
40004bf0: 90 10 00 18 mov %i0, %o0
if ( len >= sizeof( buf ) - UNTAR_FILE_NAME_SIZE - 2 ) {
40004bf4: 80 a2 20 99 cmp %o0, 0x99
40004bf8: 18 80 00 28 bgu 40004c98 <rtems_tarfs_load+0xb0>
40004bfc: ba 10 00 08 mov %o0, %i5
return -1;
}
eval_flags = RTEMS_FS_FOLLOW_LINK;
loc = rtems_filesystem_eval_path_start( &eval_ctx, mountpoint, eval_flags );
40004c00: 94 10 20 18 mov 0x18, %o2
40004c04: 92 10 00 18 mov %i0, %o1
40004c08: 7f ff fb 3c call 400038f8 <rtems_filesystem_eval_path_start>
40004c0c: 90 07 be 48 add %fp, -440, %o0
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
40004c10: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40004c14: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40004c18: f8 00 60 24 ld [ %g1 + 0x24 ], %i4
is_imfs = IMFS_is_imfs_instance( loc );
rtems_filesystem_eval_path_cleanup( &eval_ctx );
40004c1c: 7f ff fb 81 call 40003a20 <rtems_filesystem_eval_path_cleanup>
40004c20: 90 07 be 48 add %fp, -440, %o0
if ( !is_imfs ) {
40004c24: 03 10 00 16 sethi %hi(0x40005800), %g1
40004c28: 82 10 61 04 or %g1, 0x104, %g1 ! 40005904 <IMFS_node_clone>
40004c2c: 80 a7 00 01 cmp %i4, %g1
40004c30: 12 80 00 1a bne 40004c98 <rtems_tarfs_load+0xb0>
40004c34: 94 10 00 1d mov %i5, %o2
return -1;
}
ctx.printer = NULL;
40004c38: c0 27 be fc clr [ %fp + -260 ]
ctx.file_path = memcpy( buf, mountpoint, len );
40004c3c: 92 10 00 18 mov %i0, %o1
40004c40: 40 00 66 c3 call 4001e74c <memcpy>
40004c44: 90 07 bf 00 add %fp, -256, %o0
if ( len > 0 && ctx.file_path[ len - 1 ] != '/') {
40004c48: 80 a7 60 00 cmp %i5, 0
40004c4c: 12 80 00 15 bne 40004ca0 <rtems_tarfs_load+0xb8>
40004c50: d0 27 be 80 st %o0, [ %fp + -384 ]
ctx.file_path[ len ] = '/';
ctx.file_name = ctx.file_path + len + 1;
40004c54: d0 27 be 84 st %o0, [ %fp + -380 ]
40004c58: 10 80 00 0a b 40004c80 <rtems_tarfs_load+0x98>
40004c5c: ba 10 20 00 clr %i5
ptr = 0;
while ( ptr + 512 <= tar_size ) {
int retval;
retval = Untar_ProcessHeader( &ctx, (const char *) &tar_image[ ptr ] );
40004c60: 40 00 33 f8 call 40011c40 <Untar_ProcessHeader>
40004c64: 90 07 be 80 add %fp, -384, %o0
if ( retval != UNTAR_SUCCESSFUL ) {
40004c68: 80 a2 20 00 cmp %o0, 0
40004c6c: 12 80 00 0b bne 40004c98 <rtems_tarfs_load+0xb0>
40004c70: c2 0f be f8 ldub [ %fp + -264 ], %g1
return -1;
}
ptr += 512;
if ( ctx.linkflag == REGTYPE ) {
40004c74: 80 a0 60 30 cmp %g1, 0x30
40004c78: 02 80 00 13 be 40004cc4 <rtems_tarfs_load+0xdc>
40004c7c: ba 10 00 1c mov %i4, %i5
while ( ptr + 512 <= tar_size ) {
40004c80: b8 07 62 00 add %i5, 0x200, %i4
40004c84: 80 a7 00 1a cmp %i4, %i2
40004c88: 08 bf ff f6 bleu 40004c60 <rtems_tarfs_load+0x78>
40004c8c: 92 06 40 1d add %i1, %i5, %o1
ptr += 512 * ctx.nblocks;
}
}
return 0;
}
40004c90: 81 c7 e0 08 ret
<== NOT EXECUTED
40004c94: 91 e8 20 00 restore %g0, 0, %o0
return -1;
40004c98: 81 c7 e0 08 ret
<== NOT EXECUTED
40004c9c: 91 e8 3f ff restore %g0, -1, %o0
40004ca0: 82 02 00 1d add %o0, %i5, %g1
if ( len > 0 && ctx.file_path[ len - 1 ] != '/') {
40004ca4: c4 48 7f ff ldsb [ %g1 + -1 ], %g2
40004ca8: 80 a0 a0 2f cmp %g2, 0x2f
40004cac: 02 80 00 11 be 40004cf0 <rtems_tarfs_load+0x108>
40004cb0: 84 10 20 2f mov 0x2f, %g2
ctx.file_name = ctx.file_path + len + 1;
40004cb4: 82 07 60 01 add %i5, 1, %g1
<== NOT EXECUTED
ctx.file_path[ len ] = '/';
40004cb8: c4 2a 00 1d stb %g2, [ %o0 + %i5 ]
<== NOT EXECUTED
ctx.file_name = ctx.file_path + len + 1;
40004cbc: 10 bf ff e6 b 40004c54 <rtems_tarfs_load+0x6c>
<== NOT EXECUTED
40004cc0: 90 02 00 01 add %o0, %g1, %o0
<== NOT EXECUTED
retval = IMFS_make_linearfile(
40004cc4: d6 07 be f0 ld [ %fp + -272 ], %o3
40004cc8: d2 07 be ec ld [ %fp + -276 ], %o1
40004ccc: d0 07 be 80 ld [ %fp + -384 ], %o0
40004cd0: 40 00 00 0a call 40004cf8 <IMFS_make_linearfile>
40004cd4: 94 06 40 1c add %i1, %i4, %o2
if ( retval != 0 ) {
40004cd8: 80 a2 20 00 cmp %o0, 0
40004cdc: 12 bf ff ef bne 40004c98 <rtems_tarfs_load+0xb0>
40004ce0: c2 07 be f4 ld [ %fp + -268 ], %g1
ptr += 512 * ctx.nblocks;
40004ce4: 83 28 60 09 sll %g1, 9, %g1
40004ce8: 10 bf ff e6 b 40004c80 <rtems_tarfs_load+0x98>
40004cec: ba 00 40 1c add %g1, %i4, %i5
40004cf0: 10 bf ff d9 b 40004c54 <rtems_tarfs_load+0x6c>
40004cf4: 90 10 00 01 mov %g1, %o0