RTEMS-6
Annotated Report
libimfs
Sun Feb 28 22:26:49 2021
40002ed4 <IMFS_add_node>:
#endif
#include <rtems/imfs.h>
int IMFS_add_node( const char *path, IMFS_jnode_t *node, void *arg )
{
40002ed4: 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;
40002ed8: 7f ff ff 63 call 40002c64 <rtems_current_user_env_get>
40002edc: fa 06 60 14 ld [ %i1 + 0x14 ], %i5
40002ee0: d8 02 20 08 ld [ %o0 + 8 ], %o4
40002ee4: ba 2f 40 0c andn %i5, %o4, %i5
switch (mode & S_IFMT) {
40002ee8: 03 00 00 3c sethi %hi(0xf000), %g1
40002eec: 05 00 00 18 sethi %hi(0x6000), %g2
40002ef0: 82 0f 40 01 and %i5, %g1, %g1
40002ef4: 80 a0 40 02 cmp %g1, %g2
40002ef8: 02 80 00 14 be 40002f48 <IMFS_add_node+0x74> <== NEVER TAKEN
40002efc: 94 10 20 18 mov 0x18, %o2
40002f00: 08 80 00 0e bleu 40002f38 <IMFS_add_node+0x64> <== ALWAYS TAKEN
40002f04: 82 00 70 00 add %g1, -4096, %g1
40002f08: 03 00 00 2c sethi %hi(0xb000), %g1 <== NOT EXECUTED
40002f0c: 05 00 00 20 sethi %hi(0x8000), %g2 <== NOT EXECUTED
40002f10: 82 0f 40 01 and %i5, %g1, %g1 <== NOT EXECUTED
40002f14: 80 a0 40 02 cmp %g1, %g2 <== NOT EXECUTED
40002f18: 02 80 00 0d be 40002f4c <IMFS_add_node+0x78> <== NOT EXECUTED
40002f1c: 92 10 00 18 mov %i0, %o1 <== NOT EXECUTED
case S_IFIFO:
case S_IFREG:
case S_IFSOCK:
break;
default:
errno = EINVAL;
40002f20: 40 00 33 37 call 4000fbfc <__errno>
40002f24: b0 10 3f ff mov -1, %i0
40002f28: 82 10 20 16 mov 0x16, %g1
40002f2c: c2 22 00 00 st %g1, [ %o0 ]
return -1;
40002f30: 81 c7 e0 08 ret
40002f34: 81 e8 00 00 restore
switch (mode & S_IFMT) {
40002f38: 05 3f ff f8 sethi %hi(0xffffe000), %g2
40002f3c: 80 88 40 02 btst %g1, %g2
40002f40: 12 bf ff f8 bne 40002f20 <IMFS_add_node+0x4c>
40002f44: 94 10 20 18 mov 0x18, %o2
}
eval_flags = RTEMS_FS_FOLLOW_LINK;
currentloc = rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
40002f48: 92 10 00 18 mov %i0, %o1
40002f4c: 7f ff fd 37 call 40002428 <rtems_filesystem_eval_path_start>
40002f50: 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;
40002f54: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40002f58: c2 00 60 0c ld [ %g1 + 0xc ], %g1
if ( IMFS_is_imfs_instance( currentloc ) ) {
40002f5c: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
40002f60: 03 10 00 10 sethi %hi(0x40004000), %g1
40002f64: 82 10 62 b8 or %g1, 0x2b8, %g1 ! 400042b8 <IMFS_node_clone>
40002f68: 80 a0 80 01 cmp %g2, %g1
40002f6c: 02 80 00 09 be 40002f90 <IMFS_add_node+0xbc>
40002f70: 92 10 20 86 mov 0x86, %o1
}
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
40002f74: 90 07 bf c8 add %fp, -56, %o0
40002f78: 7f ff fd 38 call 40002458 <rtems_filesystem_eval_path_error>
40002f7c: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
40002f80: 7f ff fd 4c call 400024b0 <rtems_filesystem_eval_path_cleanup>
40002f84: 90 07 bf c8 add %fp, -56, %o0
return rv;
}
40002f88: 81 c7 e0 08 ret
40002f8c: 81 e8 00 00 restore
rtems_filesystem_eval_path_set_path( &ctx, node->name, node->namelen );
40002f90: c2 16 60 10 lduh [ %i1 + 0x10 ], %g1
ctx->pathlen = pathlen;
40002f94: c2 27 bf cc st %g1, [ %fp + -52 ]
ctx->flags = flags;
40002f98: 82 10 20 60 mov 0x60, %g1
ctx->path = path;
40002f9c: c4 06 60 0c ld [ %i1 + 0xc ], %g2
ctx->flags = flags;
40002fa0: c2 27 bf d8 st %g1, [ %fp + -40 ]
rtems_filesystem_eval_path_continue( &ctx );
40002fa4: 90 07 bf c8 add %fp, -56, %o0
40002fa8: 7f ff fc 92 call 400021f0 <rtems_filesystem_eval_path_continue>
40002fac: c4 27 bf c8 st %g2, [ %fp + -56 ]
return ctx->token;
40002fb0: c2 07 bf d0 ld [ %fp + -48 ], %g1
if ( rtems_filesystem_eval_path_get_token( &ctx ) == node->name ) {
40002fb4: d4 06 60 0c ld [ %i1 + 0xc ], %o2
40002fb8: 80 a2 80 01 cmp %o2, %g1
40002fbc: 02 80 00 0b be 40002fe8 <IMFS_add_node+0x114>
40002fc0: 80 a0 60 00 cmp %g1, 0
if ( rtems_filesystem_eval_path_get_token( &ctx ) != NULL ) {
40002fc4: 02 80 00 12 be 4000300c <IMFS_add_node+0x138> <== NEVER TAKEN
40002fc8: 90 07 bf c8 add %fp, -56, %o0
rtems_filesystem_eval_path_error( &ctx, EINVAL );
40002fcc: 7f ff fd 23 call 40002458 <rtems_filesystem_eval_path_error>
40002fd0: 92 10 20 16 mov 0x16, %o1
rv = -1;
40002fd4: b0 10 3f ff mov -1, %i0
rtems_filesystem_eval_path_cleanup( &ctx );
40002fd8: 7f ff fd 36 call 400024b0 <rtems_filesystem_eval_path_cleanup>
40002fdc: 90 07 bf c8 add %fp, -56, %o0
}
40002fe0: 81 c7 e0 08 ret
40002fe4: 81 e8 00 00 restore
node = IMFS_initialize_node(
40002fe8: d6 16 60 10 lduh [ %i1 + 0x10 ], %o3
40002fec: d2 06 60 38 ld [ %i1 + 0x38 ], %o1
40002ff0: 9a 10 00 1a mov %i2, %o5
40002ff4: 98 10 00 1d mov %i5, %o4
40002ff8: 40 00 04 90 call 40004238 <IMFS_initialize_node>
40002ffc: 90 10 00 19 mov %i1, %o0
if ( node != NULL ) {
40003000: 82 92 20 00 orcc %o0, 0, %g1
40003004: 12 80 00 07 bne 40003020 <IMFS_add_node+0x14c>
40003008: fa 07 bf e8 ld [ %fp + -24 ], %i5
rv = -1;
4000300c: b0 10 3f ff mov -1, %i0
rtems_filesystem_eval_path_cleanup( &ctx );
40003010: 7f ff fd 28 call 400024b0 <rtems_filesystem_eval_path_cleanup>
40003014: 90 07 bf c8 add %fp, -56, %o0
}
40003018: 81 c7 e0 08 ret
4000301c: 81 e8 00 00 restore
old_last = tail->previous;
40003020: c4 07 60 48 ld [ %i5 + 0x48 ], %g2
return &the_chain->Tail.Node;
40003024: 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;
40003028: fa 20 60 08 st %i5, [ %g1 + 8 ]
_Timecounter_Getbintime( &now );
4000302c: 90 07 bf b8 add %fp, -72, %o0
the_node->next = tail;
40003030: c6 20 40 00 st %g3, [ %g1 ]
rv = 0;
40003034: b0 10 20 00 clr %i0
tail->previous = the_node;
40003038: c2 27 60 48 st %g1, [ %i5 + 0x48 ]
old_last->next = the_node;
4000303c: c2 20 80 00 st %g1, [ %g2 ]
40003040: 40 00 07 73 call 40004e0c <_Timecounter_Getbintime>
40003044: c4 20 60 04 st %g2, [ %g1 + 4 ]
return now.sec;
40003048: c4 1f bf b8 ldd [ %fp + -72 ], %g2
jnode->stat_mtime = now;
4000304c: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
40003050: 10 bf ff cc b 40002f80 <IMFS_add_node+0xac>
40003054: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
40004330 <IMFS_do_nothing_destroy>:
void IMFS_do_nothing_destroy( IMFS_jnode_t *node )
{
(void) node;
}
40004330: 81 c3 e0 08 retl <== NOT EXECUTED
40004334: 01 00 00 00 nop <== NOT EXECUTED
400028b8 <IMFS_eval_path_devfs>:
return NULL;
}
void IMFS_eval_path_devfs( rtems_filesystem_eval_path_context_t *ctx )
{
400028b8: 9d e3 bf a0 save %sp, -96, %sp
return ctx->pathlen;
400028bc: f8 06 20 04 ld [ %i0 + 4 ], %i4
400028c0: 82 10 20 01 mov 1, %g1
400028c4: 3b 10 00 32 sethi %hi(0x4000c800), %i5
match = IMFS_devfs_dirs[ i ].len == pathlen
400028c8: 82 08 60 ff and %g1, 0xff, %g1
400028cc: ba 17 60 51 or %i5, 0x51, %i5
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;
400028d0: f2 06 20 20 ld [ %i0 + 0x20 ], %i1
return ctx->path;
400028d4: f4 06 00 00 ld [ %i0 ], %i2
&& memcmp( IMFS_devfs_dirs[ i ].name, path, pathlen ) == 0;
400028d8: 80 a7 00 01 cmp %i4, %g1
400028dc: 02 80 00 0b be 40002908 <IMFS_eval_path_devfs+0x50> <== NEVER TAKEN
400028e0: b6 07 60 10 add %i5, 0x10, %i3
for ( i = 0; i < RTEMS_ARRAY_SIZE( IMFS_devfs_dirs ); ++i ) {
400028e4: ba 07 60 04 add %i5, 4, %i5
400028e8: 80 a6 c0 1d cmp %i3, %i5
400028ec: 22 80 00 16 be,a 40002944 <IMFS_eval_path_devfs+0x8c>
400028f0: fa 06 60 40 ld [ %i1 + 0x40 ], %i5
match = IMFS_devfs_dirs[ i ].len == pathlen
400028f4: c2 0f 7f ff ldub [ %i5 + -1 ], %g1
400028f8: 82 08 60 ff and %g1, 0xff, %g1
&& memcmp( IMFS_devfs_dirs[ i ].name, path, pathlen ) == 0;
400028fc: 80 a7 00 01 cmp %i4, %g1
40002900: 32 bf ff fa bne,a 400028e8 <IMFS_eval_path_devfs+0x30>
40002904: ba 07 60 04 add %i5, 4, %i5
40002908: 94 10 00 1c mov %i4, %o2
4000290c: 92 10 00 1a mov %i2, %o1
40002910: 40 00 24 af call 4000bbcc <memcmp>
40002914: 90 10 00 1d mov %i5, %o0
40002918: 80 a2 20 00 cmp %o0, 0
4000291c: 32 bf ff f3 bne,a 400028e8 <IMFS_eval_path_devfs+0x30> <== NEVER TAKEN
40002920: ba 07 60 04 add %i5, 4, %i5 <== NOT EXECUTED
eval_flags &= ~RTEMS_FS_EXCLUSIVE;
40002924: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
40002928: 82 08 7f bf and %g1, -65, %g1
ctx->pathlen = 0;
4000292c: c0 26 20 04 clr [ %i0 + 4 ]
40002930: b8 10 20 00 clr %i4
entry = IMFS_devfs_is_dir( ctx, dir );
if ( entry != NULL ) {
40002934: 80 a6 60 00 cmp %i1, 0
40002938: 12 80 00 28 bne 400029d8 <IMFS_eval_path_devfs+0x120> <== ALWAYS TAKEN
4000293c: c2 26 20 10 st %g1, [ %i0 + 0x10 ]
return _Chain_Immutable_head( the_chain )->next;
40002940: fa 06 60 40 ld [ %i1 + 0x40 ], %i5 <== NOT EXECUTED
return &the_chain->Tail.Node;
40002944: b6 06 60 44 add %i1, 0x44, %i3
while ( current != tail ) {
40002948: 80 a7 40 1b cmp %i5, %i3
4000294c: 32 80 00 08 bne,a 4000296c <IMFS_eval_path_devfs+0xb4> <== ALWAYS TAKEN
40002950: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1
ctx->token = token;
40002954: 10 80 00 25 b 400029e8 <IMFS_eval_path_devfs+0x130> <== NOT EXECUTED
40002958: f4 26 20 08 st %i2, [ %i0 + 8 ] <== NOT EXECUTED
4000295c: 80 a6 c0 1d cmp %i3, %i5
40002960: 22 80 00 22 be,a 400029e8 <IMFS_eval_path_devfs+0x130>
40002964: f4 26 20 08 st %i2, [ %i0 + 8 ]
match = entry->namelen == pathlen
40002968: c2 17 60 10 lduh [ %i5 + 0x10 ], %g1
&& memcmp( entry->name, path, pathlen ) == 0;
4000296c: 80 a0 40 1c cmp %g1, %i4
40002970: 32 bf ff fb bne,a 4000295c <IMFS_eval_path_devfs+0xa4>
40002974: fa 07 40 00 ld [ %i5 ], %i5
40002978: d0 07 60 0c ld [ %i5 + 0xc ], %o0
4000297c: 94 10 00 1c mov %i4, %o2
40002980: 40 00 24 93 call 4000bbcc <memcmp>
40002984: 92 10 00 1a mov %i2, %o1
40002988: 80 a2 20 00 cmp %o0, 0
4000298c: 32 bf ff f4 bne,a 4000295c <IMFS_eval_path_devfs+0xa4>
40002990: 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 ) {
40002994: c2 06 20 10 ld [ %i0 + 0x10 ], %g1
40002998: 80 88 60 40 btst 0x40, %g1
4000299c: 12 80 00 11 bne 400029e0 <IMFS_eval_path_devfs+0x128> <== NEVER TAKEN
400029a0: 01 00 00 00 nop
--dir->Node.reference_count;
400029a4: c2 16 60 18 lduh [ %i1 + 0x18 ], %g1
400029a8: 82 00 7f ff add %g1, -1, %g1
400029ac: c2 36 60 18 sth %g1, [ %i1 + 0x18 ]
loc->handlers = node->control->handlers;
400029b0: c4 07 60 38 ld [ %i5 + 0x38 ], %g2
++entry->reference_count;
400029b4: c2 17 60 18 lduh [ %i5 + 0x18 ], %g1
400029b8: c4 00 80 00 ld [ %g2 ], %g2
currentloc->node_access = entry;
currentloc->node_access_2 = IMFS_generic_get_context_by_node( entry );
400029bc: c6 07 60 40 ld [ %i5 + 0x40 ], %g3
++entry->reference_count;
400029c0: 82 00 60 01 inc %g1
400029c4: c2 37 60 18 sth %g1, [ %i5 + 0x18 ]
currentloc->node_access = entry;
400029c8: fa 26 20 20 st %i5, [ %i0 + 0x20 ]
currentloc->node_access_2 = IMFS_generic_get_context_by_node( entry );
400029cc: c6 26 20 24 st %g3, [ %i0 + 0x24 ]
400029d0: c4 26 20 28 st %g2, [ %i0 + 0x28 ]
ctx->pathlen = 0;
400029d4: c0 26 20 04 clr [ %i0 + 4 ]
}
400029d8: 81 c7 e0 08 ret
400029dc: 81 e8 00 00 restore
IMFS_Set_handlers( currentloc );
rtems_filesystem_eval_path_clear_path( ctx );
} else {
rtems_filesystem_eval_path_error( ctx, EEXIST );
400029e0: 7f ff fc d2 call 40001d28 <rtems_filesystem_eval_path_error> <== NOT EXECUTED
400029e4: 93 e8 20 11 restore %g0, 0x11, %o1 <== NOT EXECUTED
ctx->tokenlen = tokenlen;
400029e8: f8 26 20 0c st %i4, [ %i0 + 0xc ]
ctx->pathlen = 0;
400029ec: c0 26 20 04 clr [ %i0 + 4 ]
}
400029f0: 81 c7 e0 08 ret
400029f4: 81 e8 00 00 restore
400079b4 <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
)
{
400079b4: 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;
400079b8: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
400079bc: c4 00 60 08 ld [ %g1 + 8 ], %g2
400079c0: f6 00 40 00 ld [ %g1 ], %i3
400079c4: f8 00 60 04 ld [ %g1 + 4 ], %i4
400079c8: c8 00 60 0c ld [ %g1 + 0xc ], %g4
400079cc: c6 00 60 10 ld [ %g1 + 0x10 ], %g3
400079d0: c2 00 60 14 ld [ %g1 + 0x14 ], %g1
jnode = (IMFS_jnode_t *)loc.node_access;
400079d4: ba 10 00 02 mov %g2, %i5
loc = temp_mt_entry->mt_fs_root->location;
400079d8: c4 27 bf f0 st %g2, [ %fp + -16 ]
return S_ISDIR( node->st_mode );
400079dc: 35 00 00 3c sethi %hi(0xf000), %i2
400079e0: c2 27 bf fc st %g1, [ %fp + -4 ]
400079e4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
loc->handlers = node->control->handlers;
400079e8: c4 07 60 38 ld [ %i5 + 0x38 ], %g2
400079ec: c4 00 80 00 ld [ %g2 ], %g2
400079f0: c6 27 bf f8 st %g3, [ %fp + -8 ]
return S_ISDIR( node->st_mode );
400079f4: 82 08 40 1a and %g1, %i2, %g1
400079f8: 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 ) ) {
400079fc: 37 00 00 10 sethi %hi(0x4000), %i3
loc = temp_mt_entry->mt_fs_root->location;
40007a00: f8 27 bf ec st %i4, [ %fp + -20 ]
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
40007a04: 80 a0 40 1b cmp %g1, %i3
next = jnode->Parent;
40007a08: f8 07 60 08 ld [ %i5 + 8 ], %i4
loc = temp_mt_entry->mt_fs_root->location;
40007a0c: c8 27 bf f4 st %g4, [ %fp + -12 ]
loc.node_access = (void *)jnode;
40007a10: fa 27 bf f0 st %i5, [ %fp + -16 ]
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
40007a14: 12 80 00 14 bne 40007a64 <IMFS_fsunmount+0xb0> <== NEVER TAKEN
40007a18: c4 27 bf f8 st %g2, [ %fp + -8 ]
return _Chain_Immutable_head( the_chain )->next;
40007a1c: c4 07 60 40 ld [ %i5 + 0x40 ], %g2
return &the_chain->Tail.Node;
40007a20: 82 07 60 44 add %i5, 0x44, %g1
40007a24: 80 a0 80 01 cmp %g2, %g1
40007a28: 02 80 00 10 be 40007a68 <IMFS_fsunmount+0xb4>
40007a2c: 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);
40007a30: 80 a0 a0 00 cmp %g2, 0
40007a34: 02 80 00 23 be 40007ac0 <IMFS_fsunmount+0x10c> <== NEVER TAKEN
40007a38: b8 10 00 02 mov %g2, %i4
40007a3c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
40007a40: ba 10 00 1c mov %i4, %i5
loc->handlers = node->control->handlers;
40007a44: c4 07 60 38 ld [ %i5 + 0x38 ], %g2
40007a48: c4 00 80 00 ld [ %g2 ], %g2
next = jnode->Parent;
40007a4c: f8 07 60 08 ld [ %i5 + 8 ], %i4
loc.node_access = (void *)jnode;
40007a50: fa 27 bf f0 st %i5, [ %fp + -16 ]
return S_ISDIR( node->st_mode );
40007a54: 82 08 40 1a and %g1, %i2, %g1
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
40007a58: 80 a0 40 1b cmp %g1, %i3
40007a5c: 02 bf ff f0 be 40007a1c <IMFS_fsunmount+0x68>
40007a60: c4 27 bf f8 st %g2, [ %fp + -8 ]
result = IMFS_rmnod( NULL, &loc );
40007a64: 92 07 bf e8 add %fp, -24, %o1
40007a68: 7f ff f3 67 call 40004804 <IMFS_rmnod>
40007a6c: 90 10 20 00 clr %o0
if ( result != 0 )
40007a70: 80 a2 20 00 cmp %o0, 0
40007a74: 12 80 00 15 bne 40007ac8 <IMFS_fsunmount+0x114> <== NEVER TAKEN
40007a78: 11 37 ab 6f sethi %hi(0xdeadbc00), %o0
IMFS_node_destroy( jnode );
40007a7c: 7f ff f2 ef call 40004638 <IMFS_node_destroy>
40007a80: 90 10 00 1d mov %i5, %o0
if ( jnode != NULL ) {
40007a84: 80 a7 20 00 cmp %i4, 0
40007a88: 02 80 00 0e be 40007ac0 <IMFS_fsunmount+0x10c>
40007a8c: 01 00 00 00 nop
40007a90: c2 07 20 14 ld [ %i4 + 0x14 ], %g1
40007a94: 84 08 40 1a and %g1, %i2, %g2
if ( IMFS_is_directory( jnode ) ) {
40007a98: 80 a0 80 1b cmp %g2, %i3
40007a9c: 32 bf ff ea bne,a 40007a44 <IMFS_fsunmount+0x90> <== NEVER TAKEN
40007aa0: ba 10 00 1c mov %i4, %i5 <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
40007aa4: c4 07 20 40 ld [ %i4 + 0x40 ], %g2
return &the_chain->Tail.Node;
40007aa8: 86 07 20 44 add %i4, 0x44, %g3
if ( jnode_has_children( jnode ) )
40007aac: 80 a0 80 03 cmp %g2, %g3
40007ab0: 12 bf ff e1 bne 40007a34 <IMFS_fsunmount+0x80>
40007ab4: 80 a0 a0 00 cmp %g2, 0
40007ab8: 10 bf ff e3 b 40007a44 <IMFS_fsunmount+0x90>
40007abc: ba 10 00 1c mov %i4, %i5
}
40007ac0: 81 c7 e0 08 ret
40007ac4: 81 e8 00 00 restore
rtems_fatal_error_occurred( 0xdeadbeef );
40007ac8: 7f ff f4 38 call 40004ba8 <rtems_fatal_error_occurred> <== NOT EXECUTED
40007acc: 90 12 22 ef or %o0, 0x2ef, %o0 <== NOT EXECUTED
40007ad0: 01 00 00 00 nop <== NOT EXECUTED
40006738 <IMFS_make_node>:
mode_t mode,
const IMFS_node_control *node_control,
size_t node_size,
void *context
)
{
40006738: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
4000673c: 7f ff fd 0c call 40005b6c <rtems_current_user_env_get>
40006740: 01 00 00 00 nop
40006744: da 02 20 08 ld [ %o0 + 8 ], %o5
40006748: b2 2e 40 0d andn %i1, %o5, %i1
switch (mode & S_IFMT) {
4000674c: 03 00 00 3c sethi %hi(0xf000), %g1
40006750: 05 00 00 18 sethi %hi(0x6000), %g2
40006754: 82 0e 40 01 and %i1, %g1, %g1
40006758: 80 a0 40 02 cmp %g1, %g2
4000675c: 02 80 00 14 be 400067ac <IMFS_make_node+0x74>
40006760: 94 10 20 78 mov 0x78, %o2
40006764: 08 80 00 0e bleu 4000679c <IMFS_make_node+0x64>
40006768: 82 00 70 00 add %g1, -4096, %g1
4000676c: 03 00 00 2c sethi %hi(0xb000), %g1
40006770: 05 00 00 20 sethi %hi(0x8000), %g2
40006774: 82 0e 40 01 and %i1, %g1, %g1
40006778: 80 a0 40 02 cmp %g1, %g2
4000677c: 02 80 00 0d be 400067b0 <IMFS_make_node+0x78> <== ALWAYS TAKEN
40006780: 92 10 00 18 mov %i0, %o1
case S_IFIFO:
case S_IFREG:
case S_IFSOCK:
break;
default:
errno = EINVAL;
40006784: 40 00 3a 63 call 40015110 <__errno>
40006788: b0 10 3f ff mov -1, %i0
4000678c: 82 10 20 16 mov 0x16, %g1
40006790: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
break;
}
if ( rv == 0 ) {
40006794: 81 c7 e0 08 ret
40006798: 81 e8 00 00 restore
switch (mode & S_IFMT) {
4000679c: 05 3f ff f8 sethi %hi(0xffffe000), %g2
400067a0: 80 88 40 02 btst %g1, %g2
400067a4: 12 bf ff f8 bne 40006784 <IMFS_make_node+0x4c>
400067a8: 94 10 20 78 mov 0x78, %o2
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 =
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
400067ac: 92 10 00 18 mov %i0, %o1
400067b0: 7f ff fa 86 call 400051c8 <rtems_filesystem_eval_path_start>
400067b4: 90 07 bf c8 add %fp, -56, %o0
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
400067b8: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
400067bc: c2 00 60 0c ld [ %g1 + 0xc ], %g1
if ( IMFS_is_imfs_instance( currentloc ) ) {
400067c0: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
400067c4: 03 10 00 1d sethi %hi(0x40007400), %g1
400067c8: 82 10 60 30 or %g1, 0x30, %g1 ! 40007430 <IMFS_node_clone>
400067cc: 80 a0 80 01 cmp %g2, %g1
400067d0: 02 80 00 0a be 400067f8 <IMFS_make_node+0xc0>
400067d4: ba 10 00 08 mov %o0, %i5
IMFS_mtime_ctime_update( parent );
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
400067d8: 92 10 20 86 mov 0x86, %o1
400067dc: 90 07 bf c8 add %fp, -56, %o0
400067e0: 7f ff fa ba call 400052c8 <rtems_filesystem_eval_path_error>
400067e4: b0 10 3f ff mov -1, %i0
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
400067e8: 7f ff fa ce call 40005320 <rtems_filesystem_eval_path_cleanup>
400067ec: 90 07 bf c8 add %fp, -56, %o0
}
return rv;
}
400067f0: 81 c7 e0 08 ret
400067f4: 81 e8 00 00 restore
IMFS_jnode_t *new_node = IMFS_create_node(
400067f8: f8 23 a0 5c st %i4, [ %sp + 0x5c ]
400067fc: 9a 10 00 19 mov %i1, %o5
40006800: d8 07 bf d4 ld [ %fp + -44 ], %o4
40006804: d6 07 bf d0 ld [ %fp + -48 ], %o3
40006808: 94 10 00 1b mov %i3, %o2
4000680c: 92 10 00 1a mov %i2, %o1
40006810: 40 00 26 3c call 40010100 <IMFS_create_node>
40006814: b0 10 3f ff mov -1, %i0
if ( new_node != NULL ) {
40006818: 80 a2 20 00 cmp %o0, 0
4000681c: 02 bf ff f3 be 400067e8 <IMFS_make_node+0xb0>
40006820: 01 00 00 00 nop
IMFS_jnode_t *parent = currentloc->node_access;
40006824: fa 07 60 08 ld [ %i5 + 8 ], %i5
_Timecounter_Getbintime( &now );
40006828: 40 00 0b 96 call 40009680 <_Timecounter_Getbintime>
4000682c: 90 07 bf b8 add %fp, -72, %o0
return now.sec;
40006830: c4 1f bf b8 ldd [ %fp + -72 ], %g2
jnode->stat_mtime = now;
40006834: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
int rv = 0;
40006838: b0 10 20 00 clr %i0
jnode->stat_ctime = now;
4000683c: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
rtems_filesystem_eval_path_cleanup( &ctx );
40006840: 7f ff fa b8 call 40005320 <rtems_filesystem_eval_path_cleanup>
40006844: 90 07 bf c8 add %fp, -56, %o0
}
40006848: 81 c7 e0 08 ret
4000684c: 81 e8 00 00 restore
40003ecc <IMFS_memfile_write>:
{
40003ecc: 9d e3 bf 88 save %sp, -120, %sp
if ( last_byte > memfile->File.size ) {
40003ed0: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
last_byte = start + my_length;
40003ed4: 96 07 00 1a add %i4, %i2, %o3
if ( last_byte > memfile->File.size ) {
40003ed8: 80 a0 40 0b cmp %g1, %o3
40003edc: 0a 80 00 3f bcs 40003fd8 <IMFS_memfile_write+0x10c>
40003ee0: 80 a6 60 00 cmp %i1, 0
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
40003ee4: 03 10 00 5e sethi %hi(0x40017800), %g1
40003ee8: fa 00 60 68 ld [ %g1 + 0x68 ], %i5 ! 40017868 <imfs_memfile_bytes_per_block>
40003eec: 95 3f 60 1f sra %i5, 0x1f, %o2
40003ef0: 96 10 00 1d mov %i5, %o3
40003ef4: d4 27 bf ec st %o2, [ %fp + -20 ]
40003ef8: 92 10 00 1a mov %i2, %o1
40003efc: 40 00 2a 73 call 4000e8c8 <__moddi3>
40003f00: 90 10 00 19 mov %i1, %o0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40003f04: d4 07 bf ec ld [ %fp + -20 ], %o2
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
40003f08: a2 10 00 09 mov %o1, %l1
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40003f0c: 96 10 00 1d mov %i5, %o3
40003f10: 92 10 00 1a mov %i2, %o1
40003f14: 40 00 29 e2 call 4000e69c <__divdi3>
40003f18: 90 10 00 19 mov %i1, %o0
copied = 0;
40003f1c: a0 10 20 00 clr %l0
if ( start_offset ) {
40003f20: 80 a4 60 00 cmp %l1, 0
40003f24: 12 80 00 37 bne 40004000 <IMFS_memfile_write+0x134>
40003f28: b4 10 00 09 mov %o1, %i2
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40003f2c: 80 a7 00 1d cmp %i4, %i5
40003f30: 1a 80 00 0d bcc 40003f64 <IMFS_memfile_write+0x98>
40003f34: 92 10 00 1a mov %i2, %o1
if ( my_length ) {
40003f38: 10 80 00 15 b 40003f8c <IMFS_memfile_write+0xc0>
40003f3c: 80 a7 20 00 cmp %i4, 0
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
40003f40: 40 00 30 05 call 4000ff54 <memcpy>
40003f44: d0 02 00 00 ld [ %o0 ], %o0
my_length -= to_copy;
40003f48: b8 27 00 1d sub %i4, %i5, %i4
src += to_copy;
40003f4c: b6 06 c0 1d add %i3, %i5, %i3
block++;
40003f50: b4 06 a0 01 inc %i2
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40003f54: 80 a7 40 1c cmp %i5, %i4
40003f58: 18 80 00 0c bgu 40003f88 <IMFS_memfile_write+0xbc>
40003f5c: a0 04 00 1d add %l0, %i5, %l0
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40003f60: 92 10 00 1a mov %i2, %o1
40003f64: 94 10 20 00 clr %o2
40003f68: 7f ff fe 47 call 40003884 <IMFS_memfile_get_block_pointer>
40003f6c: 90 10 00 18 mov %i0, %o0
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
40003f70: 92 10 00 1b mov %i3, %o1
if ( !block_ptr )
40003f74: 80 a2 20 00 cmp %o0, 0
40003f78: 12 bf ff f2 bne 40003f40 <IMFS_memfile_write+0x74> <== ALWAYS TAKEN
40003f7c: 94 10 00 1d mov %i5, %o2
}
40003f80: 81 c7 e0 08 ret
40003f84: 91 e8 00 10 restore %g0, %l0, %o0
if ( my_length ) {
40003f88: 80 a7 20 00 cmp %i4, 0
40003f8c: 02 80 00 0c be 40003fbc <IMFS_memfile_write+0xf0>
40003f90: 94 10 20 00 clr %o2
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40003f94: 92 10 00 1a mov %i2, %o1
40003f98: 7f ff fe 3b call 40003884 <IMFS_memfile_get_block_pointer>
40003f9c: 90 10 00 18 mov %i0, %o0
if ( !block_ptr )
40003fa0: 80 a2 20 00 cmp %o0, 0
40003fa4: 02 bf ff f7 be 40003f80 <IMFS_memfile_write+0xb4> <== NEVER TAKEN
40003fa8: 94 10 00 1c mov %i4, %o2
memcpy( &(*block_ptr)[ 0 ], src, my_length );
40003fac: d0 02 00 00 ld [ %o0 ], %o0
40003fb0: 92 10 00 1b mov %i3, %o1
40003fb4: 40 00 2f e8 call 4000ff54 <memcpy>
40003fb8: a0 04 00 1c add %l0, %i4, %l0
_Timecounter_Getbintime( &now );
40003fbc: 40 00 03 94 call 40004e0c <_Timecounter_Getbintime>
40003fc0: 90 07 bf f0 add %fp, -16, %o0
return now.sec;
40003fc4: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_mtime = now;
40003fc8: c4 3e 20 28 std %g2, [ %i0 + 0x28 ]
jnode->stat_ctime = now;
40003fcc: c4 3e 20 30 std %g2, [ %i0 + 0x30 ]
}
40003fd0: 81 c7 e0 08 ret
40003fd4: 91 e8 00 10 restore %g0, %l0, %o0
bool zero_fill = start > memfile->File.size;
40003fd8: 04 80 00 1d ble 4000404c <IMFS_memfile_write+0x180> <== ALWAYS TAKEN
40003fdc: 92 10 20 01 mov 1, %o1
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
40003fe0: 94 10 20 00 clr %o2 <== NOT EXECUTED
40003fe4: 92 0a 60 01 and %o1, 1, %o1
40003fe8: 7f ff fe c3 call 40003af4 <IMFS_memfile_extend>
40003fec: 90 10 00 18 mov %i0, %o0
if ( status )
40003ff0: a0 92 20 00 orcc %o0, 0, %l0
40003ff4: 02 bf ff bd be 40003ee8 <IMFS_memfile_write+0x1c>
40003ff8: 03 10 00 5e sethi %hi(0x40017800), %g1
40003ffc: 30 bf ff e1 b,a 40003f80 <IMFS_memfile_write+0xb4>
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40004000: 94 10 20 00 clr %o2
40004004: 90 10 00 18 mov %i0, %o0
40004008: 7f ff fe 1f call 40003884 <IMFS_memfile_get_block_pointer>
4000400c: a0 10 20 00 clr %l0
if ( !block_ptr )
40004010: 80 a2 20 00 cmp %o0, 0
40004014: 02 bf ff db be 40003f80 <IMFS_memfile_write+0xb4> <== NEVER TAKEN
40004018: 82 27 40 11 sub %i5, %l1, %g1
4000401c: 80 a7 00 01 cmp %i4, %g1
40004020: 18 80 00 16 bgu 40004078 <IMFS_memfile_write+0x1ac>
40004024: a0 10 00 1c mov %i4, %l0
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
40004028: d0 02 00 00 ld [ %o0 ], %o0
4000402c: 92 10 00 1b mov %i3, %o1
40004030: 94 10 00 10 mov %l0, %o2
40004034: 90 02 00 11 add %o0, %l1, %o0
40004038: 40 00 2f c7 call 4000ff54 <memcpy>
4000403c: b6 06 c0 10 add %i3, %l0, %i3
block++;
40004040: b4 06 a0 01 inc %i2
my_length -= to_copy;
40004044: 10 bf ff ba b 40003f2c <IMFS_memfile_write+0x60>
40004048: b8 27 00 10 sub %i4, %l0, %i4
bool zero_fill = start > memfile->File.size;
4000404c: 02 80 00 15 be 400040a0 <IMFS_memfile_write+0x1d4> <== ALWAYS TAKEN
40004050: 80 a6 80 01 cmp %i2, %g1
40004054: 92 10 20 00 clr %o1 <== NOT EXECUTED
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
40004058: 94 10 20 00 clr %o2 <== NOT EXECUTED
4000405c: 92 0a 60 01 and %o1, 1, %o1
40004060: 7f ff fe a5 call 40003af4 <IMFS_memfile_extend>
40004064: 90 10 00 18 mov %i0, %o0
if ( status )
40004068: a0 92 20 00 orcc %o0, 0, %l0
4000406c: 02 bf ff 9f be 40003ee8 <IMFS_memfile_write+0x1c>
40004070: 03 10 00 5e sethi %hi(0x40017800), %g1
40004074: 30 bf ff c3 b,a 40003f80 <IMFS_memfile_write+0xb4>
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
40004078: d0 02 00 00 ld [ %o0 ], %o0
4000407c: a0 10 00 01 mov %g1, %l0
40004080: 92 10 00 1b mov %i3, %o1
40004084: 94 10 00 10 mov %l0, %o2
40004088: 90 02 00 11 add %o0, %l1, %o0
4000408c: 40 00 2f b2 call 4000ff54 <memcpy>
40004090: b6 06 c0 10 add %i3, %l0, %i3
block++;
40004094: b4 06 a0 01 inc %i2
my_length -= to_copy;
40004098: 10 bf ff a5 b 40003f2c <IMFS_memfile_write+0x60>
4000409c: b8 27 00 10 sub %i4, %l0, %i4
bool zero_fill = start > memfile->File.size;
400040a0: 18 bf ff d1 bgu 40003fe4 <IMFS_memfile_write+0x118>
400040a4: 94 10 20 00 clr %o2
400040a8: 10 bf ff ed b 4000405c <IMFS_memfile_write+0x190>
400040ac: 92 10 20 00 clr %o1
400041c4 <IMFS_mount>:
#endif
#include <rtems/imfs.h>
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
400041c4: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
400041c8: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
400041cc: c4 00 60 08 ld [ %g1 + 8 ], %g2
return S_ISDIR( node->st_mode );
400041d0: 07 00 00 3c sethi %hi(0xf000), %g3
400041d4: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
400041d8: 82 08 40 03 and %g1, %g3, %g1
if ( IMFS_is_directory( node ) ) {
400041dc: 07 00 00 10 sethi %hi(0x4000), %g3
400041e0: 80 a0 40 03 cmp %g1, %g3
400041e4: 12 80 00 0f bne 40004220 <IMFS_mount+0x5c>
400041e8: 01 00 00 00 nop
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == NULL ) {
400041ec: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
400041f0: 80 a0 60 00 cmp %g1, 0
400041f4: 12 80 00 05 bne 40004208 <IMFS_mount+0x44> <== NEVER TAKEN
400041f8: 01 00 00 00 nop
dir->mt_fs = mt_entry;
400041fc: f0 20 a0 4c st %i0, [ %g2 + 0x4c ]
40004200: 81 c7 e0 08 ret
40004204: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = EBUSY;
40004208: 40 00 2e 7d call 4000fbfc <__errno> <== NOT EXECUTED
4000420c: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40004210: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED
40004214: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
40004218: 81 c7 e0 08 ret <== NOT EXECUTED
4000421c: 81 e8 00 00 restore <== NOT EXECUTED
}
} else {
errno = ENOTDIR;
40004220: 40 00 2e 77 call 4000fbfc <__errno>
40004224: b0 10 3f ff mov -1, %i0
40004228: 82 10 20 14 mov 0x14, %g1
4000422c: c2 22 00 00 st %g1, [ %o0 ]
rv = -1;
}
return rv;
}
40004230: 81 c7 e0 08 ret
40004234: 81 e8 00 00 restore
40007a88 <IMFS_node_remove_directory>:
{
return dir->mt_fs != NULL;
}
IMFS_jnode_t *IMFS_node_remove_directory( IMFS_jnode_t *node )
{
40007a88: 9d e3 bf a0 save %sp, -96, %sp
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( !rtems_chain_is_empty( &dir->Entries ) ) {
40007a8c: c4 06 20 40 ld [ %i0 + 0x40 ], %g2
return &the_chain->Tail.Node;
40007a90: 82 06 20 44 add %i0, 0x44, %g1
40007a94: 80 a0 80 01 cmp %g2, %g1
40007a98: 22 80 00 08 be,a 40007ab8 <IMFS_node_remove_directory+0x30>
40007a9c: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
errno = ENOTEMPTY;
40007aa0: 40 00 20 57 call 4000fbfc <__errno>
40007aa4: b0 10 20 00 clr %i0
40007aa8: 82 10 20 5a mov 0x5a, %g1
40007aac: c2 22 00 00 st %g1, [ %o0 ]
dir = NULL;
40007ab0: 81 c7 e0 08 ret
40007ab4: 81 e8 00 00 restore
} else if ( IMFS_is_mount_point( dir ) ) {
40007ab8: 80 a0 60 00 cmp %g1, 0
40007abc: 02 80 00 06 be 40007ad4 <IMFS_node_remove_directory+0x4c> <== ALWAYS TAKEN
40007ac0: 01 00 00 00 nop
errno = EBUSY;
40007ac4: 40 00 20 4e call 4000fbfc <__errno> <== NOT EXECUTED
40007ac8: b0 10 20 00 clr %i0 ! 0 <PROM_START> <== NOT EXECUTED
40007acc: 82 10 20 10 mov 0x10, %g1 <== NOT EXECUTED
40007ad0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
dir = NULL;
}
return &dir->Node;
}
40007ad4: 81 c7 e0 08 ret
40007ad8: 81 e8 00 00 restore
40004644 <IMFS_readlink>:
sym_link = loc->node_access;
40004644: c6 02 20 08 ld [ %o0 + 8 ], %g3
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40004648: 80 a2 a0 00 cmp %o2, 0
4000464c: 12 80 00 08 bne 4000466c <IMFS_readlink+0x28> <== ALWAYS TAKEN
40004650: 90 10 20 00 clr %o0
40004654: 30 80 00 0d b,a 40004688 <IMFS_readlink+0x44> <== NOT EXECUTED
buf[i] = sym_link->name[i];
40004658: c2 2a 40 08 stb %g1, [ %o1 + %o0 ]
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
4000465c: 90 02 20 01 inc %o0
40004660: 80 a2 00 0a cmp %o0, %o2
40004664: 02 80 00 09 be 40004688 <IMFS_readlink+0x44>
40004668: 01 00 00 00 nop
4000466c: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
40004670: c4 48 40 08 ldsb [ %g1 + %o0 ], %g2
40004674: 80 a0 a0 00 cmp %g2, 0
40004678: 12 bf ff f8 bne 40004658 <IMFS_readlink+0x14>
4000467c: c2 08 40 08 ldub [ %g1 + %o0 ], %g1
40004680: 81 c3 e0 08 retl
40004684: 01 00 00 00 nop
}
40004688: 81 c3 e0 08 retl
4000468c: 01 00 00 00 nop
40004370 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
40004370: 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;
40004374: fa 06 60 08 ld [ %i1 + 8 ], %i5
new_parent = newparentloc->node_access;
if ( node->Parent == NULL ) {
40004378: c2 07 60 08 ld [ %i5 + 8 ], %g1
4000437c: 80 a0 60 00 cmp %g1, 0
40004380: 02 80 00 3d be 40004474 <IMFS_rename+0x104> <== NEVER TAKEN
40004384: f2 06 a0 08 ld [ %i2 + 8 ], %i1
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( namelen >= IMFS_NAME_MAX ) {
40004388: 80 a7 20 fe cmp %i4, 0xfe
4000438c: 18 80 00 34 bgu 4000445c <IMFS_rename+0xec>
40004390: 01 00 00 00 nop
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
}
control = malloc( sizeof( *control ) + namelen );
40004394: 40 00 0b 5a call 400070fc <malloc>
40004398: 90 07 20 14 add %i4, 0x14, %o0
if ( control == NULL ) {
4000439c: b4 92 20 00 orcc %o0, 0, %i2
400043a0: 02 80 00 3b be 4000448c <IMFS_rename+0x11c> <== NEVER TAKEN
400043a4: 92 10 00 1b mov %i3, %o1
rtems_set_errno_and_return_minus_one( ENOMEM );
}
memcpy( control->name, name, namelen );
400043a8: b0 06 a0 14 add %i2, 0x14, %i0
400043ac: 94 10 00 1c mov %i4, %o2
400043b0: 40 00 2e e9 call 4000ff54 <memcpy>
400043b4: 90 10 00 18 mov %i0, %o0
if ( node->control->node_destroy == IMFS_renamed_destroy ) {
400043b8: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
400043bc: c4 00 60 0c ld [ %g1 + 0xc ], %g2
400043c0: 37 10 00 10 sethi %hi(0x40004000), %i3
400043c4: b6 16 e3 44 or %i3, 0x344, %i3 ! 40004344 <IMFS_renamed_destroy>
400043c8: 80 a0 80 1b cmp %g2, %i3
400043cc: 22 80 00 1f be,a 40004448 <IMFS_rename+0xd8>
400043d0: c4 00 60 10 ld [ %g1 + 0x10 ], %g2
IMFS_restore_replaced_control( node );
}
control->Base = *node->control;
400043d4: c4 00 40 00 ld [ %g1 ], %g2
400043d8: c4 26 80 00 st %g2, [ %i2 ]
400043dc: 86 06 60 44 add %i1, 0x44, %g3
400043e0: c4 00 60 04 ld [ %g1 + 4 ], %g2
400043e4: c4 26 a0 04 st %g2, [ %i2 + 4 ]
_Timecounter_Getbintime( &now );
400043e8: 90 07 bf f0 add %fp, -16, %o0
400043ec: c4 00 60 08 ld [ %g1 + 8 ], %g2
400043f0: c4 26 a0 08 st %g2, [ %i2 + 8 ]
control->Base.node_destroy = IMFS_renamed_destroy;
control->replaced = node->control;
400043f4: c2 26 a0 10 st %g1, [ %i2 + 0x10 ]
control->Base.node_destroy = IMFS_renamed_destroy;
400043f8: f6 26 a0 0c st %i3, [ %i2 + 0xc ]
next = the_node->next;
400043fc: c4 07 40 00 ld [ %i5 ], %g2
previous = the_node->previous;
40004400: c2 07 60 04 ld [ %i5 + 4 ], %g1
node->control = &control->Base;
node->name = control->name;
40004404: 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;
40004408: b0 10 20 00 clr %i0
node->control = &control->Base;
4000440c: f4 27 60 38 st %i2, [ %i5 + 0x38 ]
node->namelen = namelen;
40004410: f8 37 60 10 sth %i4, [ %i5 + 0x10 ]
next->previous = previous;
40004414: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40004418: c4 20 40 00 st %g2, [ %g1 ]
old_last = tail->previous;
4000441c: c2 06 60 48 ld [ %i1 + 0x48 ], %g1
the_node->next = tail;
40004420: c6 27 40 00 st %g3, [ %i5 ]
entry_node->Parent = dir_node;
40004424: f2 27 60 08 st %i1, [ %i5 + 8 ]
tail->previous = the_node;
40004428: fa 26 60 48 st %i5, [ %i1 + 0x48 ]
old_last->next = the_node;
4000442c: fa 20 40 00 st %i5, [ %g1 ]
_Timecounter_Getbintime( &now );
40004430: 40 00 02 77 call 40004e0c <_Timecounter_Getbintime>
40004434: c2 27 60 04 st %g1, [ %i5 + 4 ]
return now.sec;
40004438: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_ctime = _IMFS_get_time();
4000443c: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
}
40004440: 81 c7 e0 08 ret
40004444: 81 e8 00 00 restore
node->control = control->replaced;
40004448: c4 27 60 38 st %g2, [ %i5 + 0x38 ]
free( control );
4000444c: 40 00 0a ad call 40006f00 <free>
40004450: 90 10 00 01 mov %g1, %o0
}
40004454: 10 bf ff e0 b 400043d4 <IMFS_rename+0x64>
40004458: c2 07 60 38 ld [ %i5 + 0x38 ], %g1
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
4000445c: 40 00 2d e8 call 4000fbfc <__errno>
40004460: b0 10 3f ff mov -1, %i0
40004464: 82 10 20 5b mov 0x5b, %g1
40004468: c2 22 00 00 st %g1, [ %o0 ]
4000446c: 81 c7 e0 08 ret
40004470: 81 e8 00 00 restore
rtems_set_errno_and_return_minus_one( EINVAL );
40004474: 40 00 2d e2 call 4000fbfc <__errno> <== NOT EXECUTED
40004478: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
4000447c: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
40004480: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
40004484: 81 c7 e0 08 ret <== NOT EXECUTED
40004488: 81 e8 00 00 restore <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4000448c: 40 00 2d dc call 4000fbfc <__errno> <== NOT EXECUTED
40004490: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
40004494: 82 10 20 0c mov 0xc, %g1 <== NOT EXECUTED
40004498: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
4000449c: 81 c7 e0 08 ret <== NOT EXECUTED
400044a0: 81 e8 00 00 restore <== NOT EXECUTED
400044a4 <IMFS_rmnod>:
int IMFS_rmnod(
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
400044a4: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = loc->node_access;
400044a8: d0 06 60 08 ld [ %i1 + 8 ], %o0
node = (*node->control->node_remove)( node );
400044ac: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
400044b0: c2 00 60 08 ld [ %g1 + 8 ], %g1
400044b4: 9f c0 40 00 call %g1
400044b8: 01 00 00 00 nop
if ( node != NULL ) {
400044bc: 80 a2 20 00 cmp %o0, 0
400044c0: 22 80 00 11 be,a 40004504 <IMFS_rmnod+0x60>
400044c4: b0 10 3f ff mov -1, %i0
--node->reference_count;
400044c8: c4 12 20 18 lduh [ %o0 + 0x18 ], %g2
--node->st_nlink;
400044cc: c2 12 20 1a lduh [ %o0 + 0x1a ], %g1
400044d0: 82 00 7f ff add %g1, -1, %g1
--node->reference_count;
400044d4: 84 00 bf ff add %g2, -1, %g2
--node->st_nlink;
400044d8: c2 32 20 1a sth %g1, [ %o0 + 0x1a ]
--node->reference_count;
400044dc: c4 32 20 18 sth %g2, [ %o0 + 0x18 ]
if ( node->Parent != NULL ) {
400044e0: c2 02 20 08 ld [ %o0 + 8 ], %g1
400044e4: 80 a0 60 00 cmp %g1, 0
400044e8: 02 80 00 07 be 40004504 <IMFS_rmnod+0x60>
400044ec: b0 10 20 00 clr %i0
node->Parent = NULL;
400044f0: c0 22 20 08 clr [ %o0 + 8 ]
next = the_node->next;
400044f4: c4 02 00 00 ld [ %o0 ], %g2
previous = the_node->previous;
400044f8: c2 02 20 04 ld [ %o0 + 4 ], %g1
next->previous = previous;
400044fc: c2 20 a0 04 st %g1, [ %g2 + 4 ]
previous->next = next;
40004500: c4 20 40 00 st %g2, [ %g1 ]
}
40004504: 81 c7 e0 08 ret
40004508: 81 e8 00 00 restore
} else {
rv = -1;
}
return rv;
}
4000450c: 81 c7 e0 08 ret <== NOT EXECUTED
40004510: 81 e8 00 00 restore <== NOT EXECUTED
40004690 <IMFS_unmount>:
#endif
#include <rtems/imfs.h>
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40004690: 9d e3 bf a0 save %sp, -96, %sp
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40004694: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
40004698: c4 00 60 08 ld [ %g1 + 8 ], %g2
return S_ISDIR( node->st_mode );
4000469c: 07 00 00 3c sethi %hi(0xf000), %g3
400046a0: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
400046a4: 82 08 40 03 and %g1, %g3, %g1
if ( IMFS_is_directory( node ) ) {
400046a8: 07 00 00 10 sethi %hi(0x4000), %g3
400046ac: 80 a0 40 03 cmp %g1, %g3
400046b0: 12 80 00 0f bne 400046ec <IMFS_unmount+0x5c> <== NEVER TAKEN
400046b4: 01 00 00 00 nop
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == mt_entry ) {
400046b8: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
400046bc: 80 a0 40 18 cmp %g1, %i0
400046c0: 12 80 00 05 bne 400046d4 <IMFS_unmount+0x44> <== NEVER TAKEN
400046c4: 01 00 00 00 nop
dir->mt_fs = NULL;
400046c8: c0 20 a0 4c clr [ %g2 + 0x4c ]
400046cc: 81 c7 e0 08 ret
400046d0: 91 e8 20 00 restore %g0, 0, %o0
} else {
errno = EINVAL;
400046d4: 40 00 2d 4a call 4000fbfc <__errno> <== NOT EXECUTED
400046d8: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400046dc: 82 10 20 16 mov 0x16, %g1 <== NOT EXECUTED
400046e0: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
400046e4: 81 c7 e0 08 ret <== NOT EXECUTED
400046e8: 81 e8 00 00 restore <== NOT EXECUTED
}
} else {
errno = ENOTDIR;
400046ec: 40 00 2d 44 call 4000fbfc <__errno> <== NOT EXECUTED
400046f0: b0 10 3f ff mov -1, %i0 <== NOT EXECUTED
400046f4: 82 10 20 14 mov 0x14, %g1 <== NOT EXECUTED
400046f8: c2 22 00 00 st %g1, [ %o0 ] <== NOT EXECUTED
rv = -1;
}
return rv;
}
400046fc: 81 c7 e0 08 ret <== NOT EXECUTED
40004700: 81 e8 00 00 restore <== NOT EXECUTED
400079cc <device_ftruncate>:
rtems_libio_t *iop,
off_t length
)
{
return 0;
}
400079cc: 81 c3 e0 08 retl <== NOT EXECUTED
400079d0: 90 10 20 00 clr %o0 <== NOT EXECUTED
40005018 <rtems_tarfs_load>:
int rtems_tarfs_load(
const char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
40005018: 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 );
4000501c: 40 00 74 17 call 40022078 <strlen>
40005020: 90 10 00 18 mov %i0, %o0
if ( len >= sizeof( buf ) - UNTAR_FILE_NAME_SIZE - 2 ) {
40005024: 80 a2 20 99 cmp %o0, 0x99
40005028: 18 80 00 29 bgu 400050cc <rtems_tarfs_load+0xb4> <== NEVER TAKEN
4000502c: 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 );
40005030: 94 10 20 18 mov 0x18, %o2
40005034: 92 10 00 18 mov %i0, %o1
40005038: 7f ff f8 e4 call 400033c8 <rtems_filesystem_eval_path_start>
4000503c: 90 07 be 48 add %fp, -440, %o0
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
40005040: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
40005044: c2 00 60 0c ld [ %g1 + 0xc ], %g1
40005048: f8 00 60 24 ld [ %g1 + 0x24 ], %i4
is_imfs = IMFS_is_imfs_instance( loc );
rtems_filesystem_eval_path_cleanup( &eval_ctx );
4000504c: 7f ff f9 35 call 40003520 <rtems_filesystem_eval_path_cleanup>
40005050: 90 07 be 48 add %fp, -440, %o0
if ( !is_imfs ) {
40005054: 03 10 00 17 sethi %hi(0x40005c00), %g1
40005058: 82 10 62 44 or %g1, 0x244, %g1 ! 40005e44 <IMFS_node_clone>
4000505c: 80 a7 00 01 cmp %i4, %g1
40005060: 12 80 00 1b bne 400050cc <rtems_tarfs_load+0xb4>
40005064: 94 10 00 1d mov %i5, %o2
return -1;
}
ctx.printer = NULL;
40005068: c0 27 be fc clr [ %fp + -260 ]
ctx.file_path = memcpy( buf, mountpoint, len );
4000506c: 92 10 00 18 mov %i0, %o1
40005070: 40 00 69 eb call 4001f81c <memcpy>
40005074: 90 07 bf 00 add %fp, -256, %o0
if ( len > 0 && ctx.file_path[ len - 1 ] != '/') {
40005078: 80 a7 60 00 cmp %i5, 0
4000507c: 12 80 00 16 bne 400050d4 <rtems_tarfs_load+0xbc> <== ALWAYS TAKEN
40005080: d0 27 be 80 st %o0, [ %fp + -384 ]
ctx.file_path[ len ] = '/';
ctx.file_name = ctx.file_path + len + 1;
40005084: d0 27 be 84 st %o0, [ %fp + -380 ]
40005088: 10 80 00 0a b 400050b0 <rtems_tarfs_load+0x98>
4000508c: ba 10 20 00 clr %i5
ptr = 0;
while ( ptr + 512 <= tar_size ) {
int retval;
retval = Untar_ProcessHeader( &ctx, (const char *) &tar_image[ ptr ] );
40005090: 40 00 05 a5 call 40006724 <Untar_ProcessHeader>
40005094: 01 00 00 00 nop
if ( retval != UNTAR_SUCCESSFUL ) {
40005098: 80 a2 20 00 cmp %o0, 0
4000509c: 12 80 00 0c bne 400050cc <rtems_tarfs_load+0xb4> <== NEVER TAKEN
400050a0: c2 0f be f8 ldub [ %fp + -264 ], %g1
return -1;
}
ptr += 512;
if ( ctx.linkflag == REGTYPE ) {
400050a4: 80 a0 60 30 cmp %g1, 0x30
400050a8: 02 80 00 14 be 400050f8 <rtems_tarfs_load+0xe0>
400050ac: d6 07 be f0 ld [ %fp + -272 ], %o3
retval = Untar_ProcessHeader( &ctx, (const char *) &tar_image[ ptr ] );
400050b0: 92 06 40 1d add %i1, %i5, %o1
while ( ptr + 512 <= tar_size ) {
400050b4: ba 07 62 00 add %i5, 0x200, %i5
400050b8: 80 a7 40 1a cmp %i5, %i2
400050bc: 08 bf ff f5 bleu 40005090 <rtems_tarfs_load+0x78>
400050c0: 90 07 be 80 add %fp, -384, %o0
ptr += 512 * ctx.nblocks;
}
}
return 0;
}
400050c4: 81 c7 e0 08 ret
400050c8: 91 e8 20 00 restore %g0, 0, %o0
return -1;
400050cc: 81 c7 e0 08 ret
400050d0: 91 e8 3f ff restore %g0, -1, %o0
ctx.file_path[ len ] = '/';
400050d4: 82 02 00 1d add %o0, %i5, %g1
if ( len > 0 && ctx.file_path[ len - 1 ] != '/') {
400050d8: c4 48 7f ff ldsb [ %g1 + -1 ], %g2
400050dc: 80 a0 a0 2f cmp %g2, 0x2f
400050e0: 02 80 00 10 be 40005120 <rtems_tarfs_load+0x108> <== ALWAYS TAKEN
400050e4: 84 10 20 2f mov 0x2f, %g2
ctx.file_name = ctx.file_path + len + 1;
400050e8: 82 07 60 01 add %i5, 1, %g1 <== NOT EXECUTED
ctx.file_path[ len ] = '/';
400050ec: c4 2a 00 1d stb %g2, [ %o0 + %i5 ] <== NOT EXECUTED
ctx.file_name = ctx.file_path + len + 1;
400050f0: 10 bf ff e5 b 40005084 <rtems_tarfs_load+0x6c> <== NOT EXECUTED
400050f4: 90 02 00 01 add %o0, %g1, %o0 <== NOT EXECUTED
retval = IMFS_make_linearfile(
400050f8: d2 07 be ec ld [ %fp + -276 ], %o1
400050fc: d0 07 be 80 ld [ %fp + -384 ], %o0
40005100: 40 00 00 50 call 40005240 <IMFS_make_linearfile>
40005104: 94 06 40 1d add %i1, %i5, %o2
if ( retval != 0 ) {
40005108: 80 a2 20 00 cmp %o0, 0
4000510c: 12 bf ff f0 bne 400050cc <rtems_tarfs_load+0xb4> <== NEVER TAKEN
40005110: c2 07 be f4 ld [ %fp + -268 ], %g1
ptr += 512 * ctx.nblocks;
40005114: 83 28 60 09 sll %g1, 9, %g1
40005118: 10 bf ff e6 b 400050b0 <rtems_tarfs_load+0x98>
4000511c: ba 07 40 01 add %i5, %g1, %i5
ctx.file_name = ctx.file_path + len;
40005120: 10 bf ff d9 b 40005084 <rtems_tarfs_load+0x6c>
40005124: 90 10 00 01 mov %g1, %o0