40010b60 <IMFS_LIMITS_AND_OPTIONS>:
40010b60: 00 00 00 05 00 00 00 06 00 00 00 07 00 00 00 ff ................
40010b70: 00 00 00 ff 00 00 00 02 00 00 00 01 00 00 00 02 ................
40010b80: 00 00 00 03 00 00 00 04 00 00 00 05 00 00 00 06 ................
40010b90: 4e 4f 4e 42 4c 4f 43 4b 00 00 00 00 00 00 00 00 NONBLOCK........
40010ba0: 41 50 50 45 4e 44 00 00 52 45 41 44 00 00 00 00 APPEND..READ....
40010bb0: 57 52 49 54 45 00 00 00 52 45 41 44 2f 57 52 49 WRITE...READ/WRI
40010bc0: 54 45 00 00 TE..
40002a98 <IMFS_chown>:
int IMFS_chown(
const rtems_filesystem_location_info_t *loc,
uid_t owner,
gid_t group
)
{
40002a98: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
IMFS_jnode_t *jnode;
jnode = (IMFS_jnode_t *) loc->node_access;
40002a9c: fa 06 20 08 ld [ %i0 + 8 ], %i5
<== NOT EXECUTED
jnode->st_uid = owner;
40002aa0: f2 37 60 1c sth %i1, [ %i5 + 0x1c ]
<== NOT EXECUTED
static inline time_t _IMFS_get_time( void )
{
struct bintime now;
/* Use most efficient way to get the time in seconds (CLOCK_REALTIME) */
_Timecounter_Getbintime( &now );
40002aa4: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
jnode->st_gid = group;
40002aa8: f4 37 60 1e sth %i2, [ %i5 + 0x1e ]
<== NOT EXECUTED
40002aac: 40 00 17 78 call 4000888c <_Timecounter_Getbintime>
<== NOT EXECUTED
40002ab0: b0 10 20 00 clr %i0
<== NOT EXECUTED
return now.sec;
40002ab4: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_mtime = _IMFS_get_time();
}
static inline void IMFS_update_ctime( IMFS_jnode_t *jnode )
{
jnode->stat_ctime = _IMFS_get_time();
40002ab8: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
<== NOT EXECUTED
IMFS_update_ctime( jnode );
return 0;
}
40002abc: 81 c7 e0 08 ret
<== NOT EXECUTED
40002ac0: 81 e8 00 00 restore
<== NOT EXECUTED
4000da0c <IMFS_create_node>:
const char *name,
size_t namelen,
mode_t mode,
void *arg
)
{
4000da0c: 9d e3 bf a0 save %sp, -96, %sp
IMFS_jnode_t *allocated_node;
IMFS_jnode_t *node;
allocated_node = calloc( 1, node_size + namelen );
4000da10: 90 10 20 01 mov 1, %o0
4000da14: 7f ff da 10 call 40004254 <calloc>
4000da18: 92 06 80 1c add %i2, %i4, %o1
if ( allocated_node == NULL ) {
4000da1c: a0 92 20 00 orcc %o0, 0, %l0
4000da20: 02 80 00 1c be 4000da90 <IMFS_create_node+0x84>
<== NEVER TAKEN
4000da24: da 07 a0 5c ld [ %fp + 0x5c ], %o5
errno = ENOMEM;
return NULL;
}
node = IMFS_initialize_node(
4000da28: 98 10 00 1d mov %i5, %o4
4000da2c: 96 10 00 1c mov %i4, %o3
4000da30: 94 04 00 1a add %l0, %i2, %o2
4000da34: 7f ff d8 d3 call 40003d80 <IMFS_initialize_node>
4000da38: 92 10 00 19 mov %i1, %o1
(char *) allocated_node + node_size,
namelen,
mode,
arg
);
if ( node != NULL ) {
4000da3c: ba 92 20 00 orcc %o0, 0, %i5
4000da40: 02 80 00 0f be 4000da7c <IMFS_create_node+0x70>
<== NEVER TAKEN
4000da44: 94 10 00 1c mov %i4, %o2
IMFS_jnode_t *parent = parentloc->node_access;
memcpy( RTEMS_DECONST( char *, node->name ), name, namelen );
4000da48: d0 07 60 0c ld [ %i5 + 0xc ], %o0
IMFS_jnode_t *parent = parentloc->node_access;
4000da4c: f4 06 20 08 ld [ %i0 + 8 ], %i2
memcpy( RTEMS_DECONST( char *, node->name ), name, namelen );
4000da50: 40 00 04 35 call 4000eb24 <memcpy>
4000da54: 92 10 00 1b mov %i3, %o1
old_last = tail->previous;
4000da58: c2 06 a0 48 ld [ %i2 + 0x48 ], %g1
return &the_chain->Tail.Node;
4000da5c: 84 06 a0 44 add %i2, 0x44, %g2
entry_node->Parent = dir_node;
4000da60: f4 27 60 08 st %i2, [ %i5 + 8 ]
the_node->next = tail;
4000da64: c4 27 40 00 st %g2, [ %i5 ]
tail->previous = the_node;
4000da68: fa 26 a0 48 st %i5, [ %i2 + 0x48 ]
old_last->next = the_node;
4000da6c: fa 20 40 00 st %i5, [ %g1 ]
the_node->previous = old_last;
4000da70: c2 27 60 04 st %g1, [ %i5 + 4 ]
} else {
free( allocated_node );
}
return node;
}
4000da74: 81 c7 e0 08 ret
4000da78: 91 e8 00 1d restore %g0, %i5, %o0
free( allocated_node );
4000da7c: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
4000da80: 7f ff da 40 call 40004380 <free>
<== NOT EXECUTED
4000da84: b0 10 00 1d mov %i5, %i0
<== NOT EXECUTED
}
4000da88: 81 c7 e0 08 ret
<== NOT EXECUTED
4000da8c: 81 e8 00 00 restore
<== NOT EXECUTED
errno = ENOMEM;
4000da90: 40 00 03 f7 call 4000ea6c <__errno>
<== NOT EXECUTED
4000da94: ba 10 20 00 clr %i5
<== NOT EXECUTED
4000da98: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
return NULL;
4000da9c: 10 bf ff f6 b 4000da74 <IMFS_create_node+0x68>
<== NOT EXECUTED
4000daa0: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40002f08 <IMFS_fchmod>:
int IMFS_fchmod(
const rtems_filesystem_location_info_t *loc,
mode_t mode
)
{
40002f08: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
IMFS_jnode_t *jnode;
jnode = loc->node_access;
40002f0c: fa 06 20 08 ld [ %i0 + 8 ], %i5
<== NOT EXECUTED
jnode->st_mode = mode;
40002f10: f2 27 60 14 st %i1, [ %i5 + 0x14 ]
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
40002f14: 40 00 16 5e call 4000888c <_Timecounter_Getbintime>
<== NOT EXECUTED
40002f18: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
return now.sec;
40002f1c: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_ctime = _IMFS_get_time();
40002f20: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
<== NOT EXECUTED
IMFS_update_ctime( jnode );
return 0;
}
40002f24: 81 c7 e0 08 ret
<== NOT EXECUTED
40002f28: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
40003d80 <IMFS_initialize_node>:
const char *name,
size_t namelen,
mode_t mode,
void *arg
)
{
40003d80: 9d e3 bf 90 save %sp, -112, %sp
struct timeval tv;
if ( namelen > IMFS_NAME_MAX ) {
40003d84: 80 a6 e0 ff cmp %i3, 0xff
40003d88: 18 80 00 19 bgu 40003dec <IMFS_initialize_node+0x6c>
<== NEVER TAKEN
40003d8c: 92 10 20 00 clr %o1
errno = ENAMETOOLONG;
return NULL;
}
gettimeofday( &tv, 0 );
40003d90: 40 00 01 aa call 40004438 <gettimeofday>
40003d94: 90 07 bf f0 add %fp, -16, %o0
/*
* Fill in the basic information
*/
node->name = name;
node->namelen = namelen;
node->reference_count = 1;
40003d98: 03 00 00 40 sethi %hi(0x10000), %g1
node->name = name;
40003d9c: f4 26 20 0c st %i2, [ %i0 + 0xc ]
node->reference_count = 1;
40003da0: 82 10 60 01 or %g1, 1, %g1
node->namelen = namelen;
40003da4: f6 36 20 10 sth %i3, [ %i0 + 0x10 ]
node->reference_count = 1;
40003da8: c2 26 20 18 st %g1, [ %i0 + 0x18 ]
node->st_nlink = 1;
node->control = node_control;
40003dac: f2 26 20 38 st %i1, [ %i0 + 0x38 ]
/*
* Fill in the mode and permission information for the jnode structure.
*/
node->st_mode = mode;
node->st_uid = geteuid();
40003db0: 40 00 01 9c call 40004420 <geteuid>
40003db4: f8 26 20 14 st %i4, [ %i0 + 0x14 ]
node->st_gid = getegid();
40003db8: 40 00 01 94 call 40004408 <getegid>
40003dbc: d0 36 20 1c sth %o0, [ %i0 + 0x1c ]
/*
* Now set all the times.
*/
node->stat_atime = (time_t) tv.tv_sec;
40003dc0: c4 1f bf f0 ldd [ %fp + -16 ], %g2
node->st_gid = getegid();
40003dc4: d0 36 20 1e sth %o0, [ %i0 + 0x1e ]
node->stat_mtime = (time_t) tv.tv_sec;
node->stat_ctime = (time_t) tv.tv_sec;
return (*node_control->node_initialize)( node, arg );
40003dc8: 92 10 00 1d mov %i5, %o1
node->stat_atime = (time_t) tv.tv_sec;
40003dcc: c4 3e 20 20 std %g2, [ %i0 + 0x20 ]
node->stat_mtime = (time_t) tv.tv_sec;
40003dd0: c4 3e 20 28 std %g2, [ %i0 + 0x28 ]
node->stat_ctime = (time_t) tv.tv_sec;
40003dd4: c4 3e 20 30 std %g2, [ %i0 + 0x30 ]
return (*node_control->node_initialize)( node, arg );
40003dd8: c2 06 60 04 ld [ %i1 + 4 ], %g1
40003ddc: 9f c0 40 00 call %g1
40003de0: 90 10 00 18 mov %i0, %o0
}
40003de4: 81 c7 e0 08 ret
40003de8: 91 e8 00 08 restore %g0, %o0, %o0
errno = ENAMETOOLONG;
40003dec: 40 00 2b 20 call 4000ea6c <__errno>
<== NOT EXECUTED
40003df0: b0 10 20 00 clr %i0
<== NOT EXECUTED
40003df4: 82 10 20 5b mov 0x5b, %g1
<== NOT EXECUTED
40003df8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
return NULL;
40003dfc: 81 c7 e0 08 ret
<== NOT EXECUTED
40003e00: 81 e8 00 00 restore
<== NOT EXECUTED
40002f7c <IMFS_initialize_support>:
{
40002f7c: 9d e3 bf a0 save %sp, -96, %sp
IMFS_fs_info_t *fs_info = mount_data->fs_info;
40002f80: fa 06 40 00 ld [ %i1 ], %i5
fs_info->mknod_controls = mount_data->mknod_controls;
40002f84: c2 06 60 08 ld [ %i1 + 8 ], %g1
40002f88: c2 27 60 50 st %g1, [ %i5 + 0x50 ]
root_node = IMFS_initialize_node(
40002f8c: 9a 10 20 00 clr %o5
40002f90: d2 00 40 00 ld [ %g1 ], %o1
40002f94: 96 10 20 00 clr %o3
40002f98: 19 00 00 10 sethi %hi(0x4000), %o4
40002f9c: 90 10 00 1d mov %i5, %o0
40002fa0: 98 13 21 ed or %o4, 0x1ed, %o4
40002fa4: 15 10 00 40 sethi %hi(0x40010000), %o2
40002fa8: 40 00 03 76 call 40003d80 <IMFS_initialize_node>
40002fac: 94 12 a2 e0 or %o2, 0x2e0, %o2 ! 400102e0 <rtems_libio_number_iops+0xf8>
mt_entry->ops = mount_data->ops;
40002fb0: c2 06 60 04 ld [ %i1 + 4 ], %g1
loc->handlers = node->control->handlers;
40002fb4: c4 02 20 38 ld [ %o0 + 0x38 ], %g2
40002fb8: c2 26 20 0c st %g1, [ %i0 + 0xc ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
40002fbc: 03 10 00 42 sethi %hi(0x40010800), %g1
40002fc0: 82 10 63 60 or %g1, 0x360, %g1 ! 40010b60 <IMFS_LIMITS_AND_OPTIONS>
mt_entry->fs_info = fs_info;
40002fc4: fa 26 20 08 st %i5, [ %i0 + 8 ]
mt_entry->pathconf_limits_and_options = &IMFS_LIMITS_AND_OPTIONS;
40002fc8: c2 26 20 2c st %g1, [ %i0 + 0x2c ]
40002fcc: c4 00 80 00 ld [ %g2 ], %g2
mt_entry->mt_fs_root->location.node_access = root_node;
40002fd0: c2 06 20 24 ld [ %i0 + 0x24 ], %g1
40002fd4: d0 20 60 08 st %o0, [ %g1 + 8 ]
40002fd8: c4 20 60 10 st %g2, [ %g1 + 0x10 ]
IMFS_determine_bytes_per_block(
40002fdc: 03 10 00 47 sethi %hi(0x40011c00), %g1
40002fe0: c6 00 63 10 ld [ %g1 + 0x310 ], %g3 ! 40011f10 <imfs_rq_memfile_bytes_per_block>
if (bit_mask == requested_bytes_per_block) {
40002fe4: 80 a0 e0 10 cmp %g3, 0x10
40002fe8: 02 80 00 0e be 40003020 <IMFS_initialize_support+0xa4> <== NEVER TAKEN
40002fec: 80 a0 e0 0f cmp %g3, 0xf
if(bit_mask > requested_bytes_per_block)
40002ff0: 04 80 00 0b ble 4000301c <IMFS_initialize_support+0xa0> <== NEVER TAKEN
40002ff4: 82 10 20 20 mov 0x20, %g1
40002ff8: 84 10 20 05 mov 5, %g2
if (bit_mask == requested_bytes_per_block) {
40002ffc: 80 a0 c0 01 cmp %g3, %g1
40003000: 22 80 00 09 be,a 40003024 <IMFS_initialize_support+0xa8>
40003004: 03 10 00 4e sethi %hi(0x40013800), %g1
if(bit_mask > requested_bytes_per_block)
40003008: 26 80 00 06 bl,a 40003020 <IMFS_initialize_support+0xa4> <== NEVER TAKEN
4000300c: 86 10 20 80 mov 0x80, %g3
<== NOT EXECUTED
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
40003010: 84 80 bf ff addcc %g2, -1, %g2
40003014: 12 bf ff fa bne 40002ffc <IMFS_initialize_support+0x80> <== ALWAYS TAKEN
40003018: 83 28 60 01 sll %g1, 1, %g1
: default_bytes_per_block);
4000301c: 86 10 20 80 mov 0x80, %g3
<== NOT EXECUTED
*dest_bytes_per_block = ((is_valid)
40003020: 03 10 00 4e sethi %hi(0x40013800), %g1
<== NOT EXECUTED
40003024: c6 20 60 cc st %g3, [ %g1 + 0xcc ] ! 400138cc <imfs_memfile_bytes_per_block>
}
40003028: 81 c7 e0 08 ret
4000302c: 91 e8 20 00 restore %g0, 0, %o0
4000311c <IMFS_link>:
{
4000311c: 9d e3 bf 88 save %sp, -120, %sp
<== NOT EXECUTED
target = targetloc->node_access;
40003120: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
if ( target->st_nlink >= LINK_MAX )
40003124: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
<== NOT EXECUTED
40003128: 80 a0 60 07 cmp %g1, 7
<== NOT EXECUTED
4000312c: 18 80 00 19 bgu 40003190 <IMFS_link+0x74>
<== NOT EXECUTED
40003130: 9a 10 21 ff mov 0x1ff, %o5
<== NOT EXECUTED
new_node = IMFS_create_node(
40003134: fa 23 a0 5c st %i5, [ %sp + 0x5c ]
<== NOT EXECUTED
40003138: 98 10 00 1b mov %i3, %o4
<== NOT EXECUTED
4000313c: 96 10 00 1a mov %i2, %o3
<== NOT EXECUTED
40003140: 94 10 20 48 mov 0x48, %o2
<== NOT EXECUTED
40003144: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
40003148: 13 10 00 40 sethi %hi(0x40010000), %o1
<== NOT EXECUTED
4000314c: 40 00 2a 30 call 4000da0c <IMFS_create_node>
<== NOT EXECUTED
40003150: 92 12 63 e8 or %o1, 0x3e8, %o1 ! 400103e8 <IMFS_node_control_hard_link>
<== NOT EXECUTED
if ( !new_node )
40003154: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40003158: 02 80 00 14 be 400031a8 <IMFS_link+0x8c>
<== NOT EXECUTED
4000315c: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
target->reference_count++;
40003160: c4 17 60 18 lduh [ %i5 + 0x18 ], %g2
<== NOT EXECUTED
target->st_nlink++;
40003164: c2 17 60 1a lduh [ %i5 + 0x1a ], %g1
<== NOT EXECUTED
target->reference_count++;
40003168: 84 00 a0 01 inc %g2
<== NOT EXECUTED
target->st_nlink++;
4000316c: 82 00 60 01 inc %g1
<== NOT EXECUTED
target->reference_count++;
40003170: c4 37 60 18 sth %g2, [ %i5 + 0x18 ]
<== NOT EXECUTED
target->st_nlink++;
40003174: c2 37 60 1a sth %g1, [ %i5 + 0x1a ]
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
40003178: 40 00 15 c5 call 4000888c <_Timecounter_Getbintime>
<== NOT EXECUTED
4000317c: b0 10 20 00 clr %i0
<== NOT EXECUTED
return now.sec;
40003180: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_ctime = _IMFS_get_time();
40003184: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
<== NOT EXECUTED
}
40003188: 81 c7 e0 08 ret
<== NOT EXECUTED
4000318c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EMLINK );
40003190: 40 00 2e 37 call 4000ea6c <__errno>
<== NOT EXECUTED
40003194: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40003198: 82 10 20 1f mov 0x1f, %g1
<== NOT EXECUTED
4000319c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400031a0: 81 c7 e0 08 ret
<== NOT EXECUTED
400031a4: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
400031a8: 40 00 2e 31 call 4000ea6c <__errno>
<== NOT EXECUTED
400031ac: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400031b0: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
400031b4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400031b8: 81 c7 e0 08 ret
<== NOT EXECUTED
400031bc: 81 e8 00 00 restore
<== NOT EXECUTED
4000daa4 <IMFS_make_generic_node>:
const char *path,
mode_t mode,
const IMFS_node_control *node_control,
void *context
)
{
4000daa4: 9d e3 bf 50 save %sp, -176, %sp
int rv = 0;
mode &= ~rtems_filesystem_umask;
4000daa8: 7f ff dd 44 call 40004fb8 <rtems_current_user_env_get>
4000daac: 01 00 00 00 nop
4000dab0: da 02 20 08 ld [ %o0 + 8 ], %o5
4000dab4: b2 2e 40 0d andn %i1, %o5, %i1
switch (mode & S_IFMT) {
4000dab8: 03 00 00 3c sethi %hi(0xf000), %g1
4000dabc: 05 00 00 18 sethi %hi(0x6000), %g2
4000dac0: 82 0e 40 01 and %i1, %g1, %g1
4000dac4: 80 a0 40 02 cmp %g1, %g2
4000dac8: 02 80 00 0c be 4000daf8 <IMFS_make_generic_node+0x54>
<== NEVER TAKEN
4000dacc: 94 10 20 78 mov 0x78, %o2
4000dad0: 08 80 00 1d bleu 4000db44 <IMFS_make_generic_node+0xa0> <== ALWAYS TAKEN
4000dad4: 05 00 00 04 sethi %hi(0x1000), %g2
4000dad8: 05 00 00 20 sethi %hi(0x8000), %g2
<== NOT EXECUTED
4000dadc: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4000dae0: 02 80 00 06 be 4000daf8 <IMFS_make_generic_node+0x54>
<== NOT EXECUTED
4000dae4: 05 00 00 30 sethi %hi(0xc000), %g2
<== NOT EXECUTED
4000dae8: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
4000daec: 12 80 00 1c bne 4000db5c <IMFS_make_generic_node+0xb8>
<== NOT EXECUTED
4000daf0: 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 =
4000daf4: 94 10 20 78 mov 0x78, %o2 ! 78 <_TLS_Alignment+0x77>
<== NOT EXECUTED
4000daf8: 92 10 00 18 mov %i0, %o1
4000dafc: 7f ff de dd call 40005670 <rtems_filesystem_eval_path_start>
4000db00: 90 07 bf c8 add %fp, -56, %o0
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
4000db04: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
4000db08: c2 00 60 0c ld [ %g1 + 0xc ], %g1
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
if ( IMFS_is_imfs_instance( currentloc ) ) {
4000db0c: c4 00 60 24 ld [ %g1 + 0x24 ], %g2
4000db10: 03 10 00 0f sethi %hi(0x40003c00), %g1
4000db14: 82 10 62 04 or %g1, 0x204, %g1 ! 40003e04 <IMFS_node_clone>
4000db18: 80 a0 80 01 cmp %g2, %g1
4000db1c: 02 80 00 16 be 4000db74 <IMFS_make_generic_node+0xd0>
<== ALWAYS TAKEN
4000db20: ba 10 00 08 mov %o0, %i5
IMFS_mtime_ctime_update( parent );
} else {
rv = -1;
}
} else {
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
4000db24: 92 10 20 86 mov 0x86, %o1
<== NOT EXECUTED
4000db28: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
4000db2c: 7f ff de 16 call 40005384 <rtems_filesystem_eval_path_error>
<== NOT EXECUTED
4000db30: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
4000db34: 7f ff de db call 400056a0 <rtems_filesystem_eval_path_cleanup>
<== NOT EXECUTED
4000db38: 90 07 bf c8 add %fp, -56, %o0
<== NOT EXECUTED
}
return rv;
}
4000db3c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000db40: 81 e8 00 00 restore
<== NOT EXECUTED
switch (mode & S_IFMT) {
4000db44: 80 a0 40 02 cmp %g1, %g2
4000db48: 02 bf ff eb be 4000daf4 <IMFS_make_generic_node+0x50>
<== NEVER TAKEN
4000db4c: 05 00 00 08 sethi %hi(0x2000), %g2
4000db50: 80 a0 40 02 cmp %g1, %g2
4000db54: 02 bf ff e9 be 4000daf8 <IMFS_make_generic_node+0x54>
<== ALWAYS TAKEN
4000db58: 94 10 20 78 mov 0x78, %o2
errno = EINVAL;
4000db5c: 40 00 03 c4 call 4000ea6c <__errno>
<== NOT EXECUTED
4000db60: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000db64: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
4000db68: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
4000db6c: 81 c7 e0 08 ret
<== NOT EXECUTED
4000db70: 81 e8 00 00 restore
<== NOT EXECUTED
IMFS_jnode_t *new_node = IMFS_create_node(
4000db74: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
4000db78: 9a 10 00 19 mov %i1, %o5
4000db7c: d8 07 bf d4 ld [ %fp + -44 ], %o4
4000db80: d6 07 bf d0 ld [ %fp + -48 ], %o3
4000db84: 94 10 20 48 mov 0x48, %o2
4000db88: 92 10 00 1a mov %i2, %o1
4000db8c: 7f ff ff a0 call 4000da0c <IMFS_create_node>
4000db90: b0 10 3f ff mov -1, %i0
if ( new_node != NULL ) {
4000db94: 80 a2 20 00 cmp %o0, 0
4000db98: 02 bf ff e7 be 4000db34 <IMFS_make_generic_node+0x90>
<== NEVER TAKEN
4000db9c: 01 00 00 00 nop
IMFS_jnode_t *parent = currentloc->node_access;
4000dba0: fa 07 60 08 ld [ %i5 + 8 ], %i5
_Timecounter_Getbintime( &now );
4000dba4: 7f ff eb 3a call 4000888c <_Timecounter_Getbintime>
4000dba8: 90 07 bf b8 add %fp, -72, %o0
return now.sec;
4000dbac: c4 1f bf b8 ldd [ %fp + -72 ], %g2
jnode->stat_mtime = now;
4000dbb0: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
int rv = 0;
4000dbb4: b0 10 20 00 clr %i0
jnode->stat_ctime = now;
4000dbb8: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
rtems_filesystem_eval_path_cleanup( &ctx );
4000dbbc: 7f ff de b9 call 400056a0 <rtems_filesystem_eval_path_cleanup>
4000dbc0: 90 07 bf c8 add %fp, -56, %o0
}
4000dbc4: 81 c7 e0 08 ret
4000dbc8: 81 e8 00 00 restore
40003a00 <IMFS_memfile_write>:
{
40003a00: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
if ( last_byte > memfile->File.size ) {
40003a04: c2 06 20 40 ld [ %i0 + 0x40 ], %g1
<== NOT EXECUTED
last_byte = start + my_length;
40003a08: 96 07 00 1a add %i4, %i2, %o3
<== NOT EXECUTED
if ( last_byte > memfile->File.size ) {
40003a0c: 80 a0 40 0b cmp %g1, %o3
<== NOT EXECUTED
40003a10: 0a 80 00 54 bcs 40003b60 <IMFS_memfile_write+0x160>
<== NOT EXECUTED
40003a14: a0 10 00 18 mov %i0, %l0
<== NOT EXECUTED
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
40003a18: 23 10 00 4e sethi %hi(0x40013800), %l1
<== NOT EXECUTED
40003a1c: e4 04 60 cc ld [ %l1 + 0xcc ], %l2 ! 400138cc <imfs_memfile_bytes_per_block>
<== NOT EXECUTED
40003a20: bb 3c a0 1f sra %l2, 0x1f, %i5
<== NOT EXECUTED
40003a24: 96 10 00 12 mov %l2, %o3
<== NOT EXECUTED
40003a28: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
40003a2c: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
40003a30: 40 00 2e 98 call 4000f490 <__moddi3>
<== NOT EXECUTED
40003a34: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40003a38: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
40003a3c: a6 10 00 09 mov %o1, %l3
<== NOT EXECUTED
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
40003a40: 96 10 00 12 mov %l2, %o3
<== NOT EXECUTED
40003a44: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
40003a48: 40 00 2e 07 call 4000f264 <__divdi3>
<== NOT EXECUTED
40003a4c: 90 10 00 19 mov %i1, %o0
<== NOT EXECUTED
40003a50: ba 10 00 12 mov %l2, %i5
<== NOT EXECUTED
40003a54: b4 10 00 09 mov %o1, %i2
<== NOT EXECUTED
if ( start_offset ) {
40003a58: 80 a4 e0 00 cmp %l3, 0
<== NOT EXECUTED
40003a5c: 12 80 00 1a bne 40003ac4 <IMFS_memfile_write+0xc4>
<== NOT EXECUTED
40003a60: b0 10 20 00 clr %i0
<== NOT EXECUTED
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40003a64: 80 a7 00 1d cmp %i4, %i5
<== NOT EXECUTED
40003a68: 1a 80 00 0e bcc 40003aa0 <IMFS_memfile_write+0xa0>
<== NOT EXECUTED
40003a6c: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
if ( my_length ) {
40003a70: 10 80 00 29 b 40003b14 <IMFS_memfile_write+0x114>
<== NOT EXECUTED
40003a74: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
40003a78: 40 00 2c 2b call 4000eb24 <memcpy>
<== NOT EXECUTED
40003a7c: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40003a80: c2 04 60 cc ld [ %l1 + 0xcc ], %g1
<== NOT EXECUTED
my_length -= to_copy;
40003a84: b8 27 00 1d sub %i4, %i5, %i4
<== NOT EXECUTED
src += to_copy;
40003a88: b6 06 c0 1d add %i3, %i5, %i3
<== NOT EXECUTED
block++;
40003a8c: b4 06 a0 01 inc %i2
<== NOT EXECUTED
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
40003a90: 80 a0 40 1c cmp %g1, %i4
<== NOT EXECUTED
40003a94: 18 80 00 1f bgu 40003b10 <IMFS_memfile_write+0x110>
<== NOT EXECUTED
40003a98: b0 06 00 1d add %i0, %i5, %i0
<== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40003a9c: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
40003aa0: 94 10 20 00 clr %o2
<== NOT EXECUTED
40003aa4: 7f ff fd d4 call 400031f4 <IMFS_memfile_get_block_pointer>
<== NOT EXECUTED
40003aa8: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
40003aac: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
if ( !block_ptr )
40003ab0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40003ab4: 12 bf ff f1 bne 40003a78 <IMFS_memfile_write+0x78>
<== NOT EXECUTED
40003ab8: 94 10 00 1d mov %i5, %o2
<== NOT EXECUTED
}
40003abc: 81 c7 e0 08 ret
<== NOT EXECUTED
40003ac0: 81 e8 00 00 restore
<== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40003ac4: 94 10 20 00 clr %o2
<== NOT EXECUTED
40003ac8: 7f ff fd cb call 400031f4 <IMFS_memfile_get_block_pointer>
<== NOT EXECUTED
40003acc: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
if ( !block_ptr )
40003ad0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40003ad4: 02 bf ff fa be 40003abc <IMFS_memfile_write+0xbc>
<== NOT EXECUTED
40003ad8: a4 24 80 13 sub %l2, %l3, %l2
<== NOT EXECUTED
40003adc: 80 a7 00 12 cmp %i4, %l2
<== NOT EXECUTED
40003ae0: 18 80 00 37 bgu 40003bbc <IMFS_memfile_write+0x1bc>
<== NOT EXECUTED
40003ae4: b0 10 00 1c mov %i4, %i0
<== NOT EXECUTED
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
40003ae8: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
40003aec: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
40003af0: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
40003af4: 90 02 00 13 add %o0, %l3, %o0
<== NOT EXECUTED
40003af8: 40 00 2c 0b call 4000eb24 <memcpy>
<== NOT EXECUTED
40003afc: b6 06 c0 18 add %i3, %i0, %i3
<== NOT EXECUTED
block++;
40003b00: b4 06 a0 01 inc %i2
<== NOT EXECUTED
40003b04: fa 04 60 cc ld [ %l1 + 0xcc ], %i5
<== NOT EXECUTED
my_length -= to_copy;
40003b08: 10 bf ff d7 b 40003a64 <IMFS_memfile_write+0x64>
<== NOT EXECUTED
40003b0c: b8 27 00 18 sub %i4, %i0, %i4
<== NOT EXECUTED
if ( my_length ) {
40003b10: 80 a7 20 00 cmp %i4, 0
<== NOT EXECUTED
40003b14: 02 80 00 0c be 40003b44 <IMFS_memfile_write+0x144>
<== NOT EXECUTED
40003b18: 94 10 20 00 clr %o2
<== NOT EXECUTED
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
40003b1c: 92 10 00 1a mov %i2, %o1
<== NOT EXECUTED
40003b20: 7f ff fd b5 call 400031f4 <IMFS_memfile_get_block_pointer>
<== NOT EXECUTED
40003b24: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
if ( !block_ptr )
40003b28: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40003b2c: 02 bf ff e4 be 40003abc <IMFS_memfile_write+0xbc>
<== NOT EXECUTED
40003b30: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
memcpy( &(*block_ptr)[ 0 ], src, my_length );
40003b34: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
40003b38: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
40003b3c: 40 00 2b fa call 4000eb24 <memcpy>
<== NOT EXECUTED
40003b40: b0 06 00 1c add %i0, %i4, %i0
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
40003b44: 40 00 13 52 call 4000888c <_Timecounter_Getbintime>
<== NOT EXECUTED
40003b48: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
return now.sec;
40003b4c: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_mtime = now;
40003b50: c4 3c 20 28 std %g2, [ %l0 + 0x28 ]
<== NOT EXECUTED
jnode->stat_ctime = now;
40003b54: c4 3c 20 30 std %g2, [ %l0 + 0x30 ]
<== NOT EXECUTED
}
40003b58: 81 c7 e0 08 ret
<== NOT EXECUTED
40003b5c: 81 e8 00 00 restore
<== NOT EXECUTED
bool zero_fill = start > memfile->File.size;
40003b60: 80 a6 60 00 cmp %i1, 0
<== NOT EXECUTED
40003b64: 04 80 00 0b ble 40003b90 <IMFS_memfile_write+0x190>
<== NOT EXECUTED
40003b68: 92 10 20 01 mov 1, %o1
<== NOT EXECUTED
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
40003b6c: 94 10 20 00 clr %o2
<== NOT EXECUTED
40003b70: 92 0a 60 01 and %o1, 1, %o1
<== NOT EXECUTED
40003b74: 7f ff fe 49 call 40003498 <IMFS_memfile_extend>
<== NOT EXECUTED
40003b78: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
if ( status )
40003b7c: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
40003b80: 02 bf ff a7 be 40003a1c <IMFS_memfile_write+0x1c>
<== NOT EXECUTED
40003b84: 23 10 00 4e sethi %hi(0x40013800), %l1
<== NOT EXECUTED
40003b88: 81 c7 e0 08 ret
<== NOT EXECUTED
40003b8c: 81 e8 00 00 restore
<== NOT EXECUTED
bool zero_fill = start > memfile->File.size;
40003b90: 02 80 00 16 be 40003be8 <IMFS_memfile_write+0x1e8>
<== NOT EXECUTED
40003b94: 80 a6 80 01 cmp %i2, %g1
<== NOT EXECUTED
40003b98: 92 10 20 00 clr %o1
<== NOT EXECUTED
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
40003b9c: 94 10 20 00 clr %o2
<== NOT EXECUTED
40003ba0: 92 0a 60 01 and %o1, 1, %o1
<== NOT EXECUTED
40003ba4: 7f ff fe 3d call 40003498 <IMFS_memfile_extend>
<== NOT EXECUTED
40003ba8: 90 10 00 10 mov %l0, %o0
<== NOT EXECUTED
if ( status )
40003bac: b0 92 20 00 orcc %o0, 0, %i0
<== NOT EXECUTED
40003bb0: 02 bf ff 9b be 40003a1c <IMFS_memfile_write+0x1c>
<== NOT EXECUTED
40003bb4: 23 10 00 4e sethi %hi(0x40013800), %l1
<== NOT EXECUTED
40003bb8: 30 bf ff f4 b,a 40003b88 <IMFS_memfile_write+0x188>
<== NOT EXECUTED
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
40003bbc: d0 02 00 00 ld [ %o0 ], %o0
<== NOT EXECUTED
40003bc0: b0 10 00 12 mov %l2, %i0
<== NOT EXECUTED
40003bc4: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
40003bc8: 94 10 00 18 mov %i0, %o2
<== NOT EXECUTED
40003bcc: 90 02 00 13 add %o0, %l3, %o0
<== NOT EXECUTED
40003bd0: 40 00 2b d5 call 4000eb24 <memcpy>
<== NOT EXECUTED
40003bd4: b6 06 c0 18 add %i3, %i0, %i3
<== NOT EXECUTED
block++;
40003bd8: b4 06 a0 01 inc %i2
<== NOT EXECUTED
40003bdc: fa 04 60 cc ld [ %l1 + 0xcc ], %i5
<== NOT EXECUTED
my_length -= to_copy;
40003be0: 10 bf ff a1 b 40003a64 <IMFS_memfile_write+0x64>
<== NOT EXECUTED
40003be4: b8 27 00 18 sub %i4, %i0, %i4
<== NOT EXECUTED
bool zero_fill = start > memfile->File.size;
40003be8: 18 bf ff e2 bgu 40003b70 <IMFS_memfile_write+0x170>
<== NOT EXECUTED
40003bec: 94 10 20 00 clr %o2
<== NOT EXECUTED
40003bf0: 10 bf ff ec b 40003ba0 <IMFS_memfile_write+0x1a0>
<== NOT EXECUTED
40003bf4: 92 10 20 00 clr %o1
<== NOT EXECUTED
40003c5c <IMFS_mknod>:
const char *name,
size_t namelen,
mode_t mode,
dev_t dev
)
{
40003c5c: 9d e3 bf 80 save %sp, -128, %sp
int rv = 0;
const IMFS_fs_info_t *fs_info = parentloc->mt_entry->fs_info;
40003c60: c2 06 20 14 ld [ %i0 + 0x14 ], %g1
{
40003c64: f8 3f bf e8 std %i4, [ %fp + -24 ]
const IMFS_mknod_control *mknod_control =
get_control( fs_info->mknod_controls, mode );
40003c68: c4 00 60 08 ld [ %g1 + 8 ], %g2
40003c6c: c6 00 a0 50 ld [ %g2 + 0x50 ], %g3
if ( S_ISDIR( mode ) ) {
40003c70: 03 00 00 3c sethi %hi(0xf000), %g1
40003c74: 05 00 00 10 sethi %hi(0x4000), %g2
40003c78: 82 0e c0 01 and %i3, %g1, %g1
40003c7c: 80 a0 40 02 cmp %g1, %g2
40003c80: 02 80 00 1f be 40003cfc <IMFS_mknod+0xa0>
40003c84: 05 00 00 2c sethi %hi(0xb000), %g2
} else if ( S_ISBLK( mode ) || S_ISCHR( mode ) ) {
40003c88: 09 00 00 08 sethi %hi(0x2000), %g4
40003c8c: 84 0e c0 02 and %i3, %g2, %g2
40003c90: 80 a0 80 04 cmp %g2, %g4
40003c94: 22 80 00 07 be,a 40003cb0 <IMFS_mknod+0x54>
<== ALWAYS TAKEN
40003c98: d2 00 e0 04 ld [ %g3 + 4 ], %o1
} else if ( S_ISFIFO( mode ) ) {
40003c9c: 05 00 00 04 sethi %hi(0x1000), %g2
<== NOT EXECUTED
40003ca0: 80 a0 40 02 cmp %g1, %g2
<== NOT EXECUTED
40003ca4: 22 80 00 03 be,a 40003cb0 <IMFS_mknod+0x54>
<== NOT EXECUTED
40003ca8: d2 00 e0 0c ld [ %g3 + 0xc ], %o1
<== NOT EXECUTED
return controls->file;
40003cac: d2 00 e0 08 ld [ %g3 + 8 ], %o1
<== NOT EXECUTED
IMFS_jnode_t *new_node;
new_node = IMFS_create_node(
40003cb0: 82 07 bf e8 add %fp, -24, %g1
40003cb4: c2 23 a0 5c st %g1, [ %sp + 0x5c ]
40003cb8: 9a 10 00 1b mov %i3, %o5
40003cbc: d4 02 60 10 ld [ %o1 + 0x10 ], %o2
40003cc0: 98 10 00 1a mov %i2, %o4
40003cc4: 96 10 00 19 mov %i1, %o3
40003cc8: 40 00 27 51 call 4000da0c <IMFS_create_node>
40003ccc: 90 10 00 18 mov %i0, %o0
name,
namelen,
mode,
&dev
);
if ( new_node != NULL ) {
40003cd0: 80 a2 20 00 cmp %o0, 0
40003cd4: 02 80 00 0c be 40003d04 <IMFS_mknod+0xa8>
<== NEVER TAKEN
40003cd8: 01 00 00 00 nop
IMFS_jnode_t *parent = parentloc->node_access;
40003cdc: fa 06 20 08 ld [ %i0 + 8 ], %i5
_Timecounter_Getbintime( &now );
40003ce0: 40 00 12 eb call 4000888c <_Timecounter_Getbintime>
40003ce4: 90 07 bf f0 add %fp, -16, %o0
return now.sec;
40003ce8: c4 1f bf f0 ldd [ %fp + -16 ], %g2
jnode->stat_mtime = now;
40003cec: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
jnode->stat_ctime = now;
40003cf0: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
int rv = 0;
40003cf4: 81 c7 e0 08 ret
40003cf8: 91 e8 20 00 restore %g0, 0, %o0
return controls->directory;
40003cfc: 10 bf ff ed b 40003cb0 <IMFS_mknod+0x54>
40003d00: d2 00 c0 00 ld [ %g3 ], %o1
} else {
rv = -1;
}
return rv;
}
40003d04: 81 c7 e0 08 ret
<== NOT EXECUTED
40003d08: 91 e8 3f ff restore %g0, -1, %o0
<== NOT EXECUTED
40010340 <IMFS_mknod_control_device>:
40010340: 40 01 03 54 40 00 2f 2c 40 00 3e 74 40 00 3e 7c @..T@./,@.>t@.>|
40010350: 00 00 00 48 ...H
400102e4 <IMFS_mknod_control_dir_default>:
400102e4: 40 01 02 f8 40 00 2c 78 40 00 2c 90 40 00 3e 7c @...@.,x@.,.@.>|
400102f4: 00 00 00 50 ...P
40010394 <IMFS_mknod_control_enosys>:
40010394: 40 01 0b 20 40 00 2f 60 40 00 3e 74 40 00 3e 7c @.. @./`@.>t@.>|
400103a4: 00 00 00 40 ...@
400103f8 <IMFS_mknod_control_memfile>:
400103f8: 40 01 04 0c 40 00 30 30 40 00 3e 74 40 00 38 9c @...@.00@.>t@.8.
40010408: 00 00 00 58 ...X
40003d0c <IMFS_mount>:
#endif
#include <rtems/imfs.h>
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
40003d0c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
40003d10: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
<== NOT EXECUTED
40003d14: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
return S_ISDIR( node->st_mode );
40003d18: 07 00 00 3c sethi %hi(0xf000), %g3
<== NOT EXECUTED
40003d1c: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
<== NOT EXECUTED
40003d20: 82 08 40 03 and %g1, %g3, %g1
<== NOT EXECUTED
if ( IMFS_is_directory( node ) ) {
40003d24: 07 00 00 10 sethi %hi(0x4000), %g3
<== NOT EXECUTED
40003d28: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
40003d2c: 12 80 00 0f bne 40003d68 <IMFS_mount+0x5c>
<== NOT EXECUTED
40003d30: 01 00 00 00 nop
<== NOT EXECUTED
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == NULL ) {
40003d34: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
<== NOT EXECUTED
40003d38: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40003d3c: 12 80 00 05 bne 40003d50 <IMFS_mount+0x44>
<== NOT EXECUTED
40003d40: 01 00 00 00 nop
<== NOT EXECUTED
dir->mt_fs = mt_entry;
40003d44: f0 20 a0 4c st %i0, [ %g2 + 0x4c ]
<== NOT EXECUTED
40003d48: 81 c7 e0 08 ret
<== NOT EXECUTED
40003d4c: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
} else {
errno = EBUSY;
40003d50: 40 00 2b 47 call 4000ea6c <__errno>
<== NOT EXECUTED
40003d54: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40003d58: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
40003d5c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40003d60: 81 c7 e0 08 ret
<== NOT EXECUTED
40003d64: 81 e8 00 00 restore
<== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40003d68: 40 00 2b 41 call 4000ea6c <__errno>
<== NOT EXECUTED
40003d6c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40003d70: 82 10 20 14 mov 0x14, %g1
<== NOT EXECUTED
40003d74: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
40003d78: 81 c7 e0 08 ret
<== NOT EXECUTED
40003d7c: 81 e8 00 00 restore
<== NOT EXECUTED
40003e1c <IMFS_node_destroy>:
void IMFS_node_destroy( IMFS_jnode_t *node )
{
40003e1c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
IMFS_assert( node->reference_count == 0 );
(*node->control->node_destroy)( node );
40003e20: c2 06 20 38 ld [ %i0 + 0x38 ], %g1
<== NOT EXECUTED
40003e24: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
40003e28: 9f c0 40 00 call %g1
<== NOT EXECUTED
40003e2c: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
}
40003e30: 81 c7 e0 08 ret
<== NOT EXECUTED
40003e34: 81 e8 00 00 restore
<== NOT EXECUTED
40003e7c <IMFS_node_destroy_default>:
void IMFS_node_destroy_default( IMFS_jnode_t *node )
{
40003e7c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
if ( ( node->flags & IMFS_NODE_FLAG_NAME_ALLOCATED ) != 0 ) {
40003e80: c2 16 20 12 lduh [ %i0 + 0x12 ], %g1
<== NOT EXECUTED
40003e84: 80 88 60 01 btst 1, %g1
<== NOT EXECUTED
40003e88: 12 80 00 04 bne 40003e98 <IMFS_node_destroy_default+0x1c>
<== NOT EXECUTED
40003e8c: 01 00 00 00 nop
<== NOT EXECUTED
free( RTEMS_DECONST( char *, node->name ) );
}
free( node );
40003e90: 40 00 01 3c call 40004380 <free>
<== NOT EXECUTED
40003e94: 81 e8 00 00 restore
<== NOT EXECUTED
free( RTEMS_DECONST( char *, node->name ) );
40003e98: 40 00 01 3a call 40004380 <free>
<== NOT EXECUTED
40003e9c: d0 06 20 0c ld [ %i0 + 0xc ], %o0
<== NOT EXECUTED
free( node );
40003ea0: 40 00 01 38 call 40004380 <free>
<== NOT EXECUTED
40003ea4: 81 e8 00 00 restore
<== NOT EXECUTED
40003e38 <IMFS_node_free>:
void IMFS_node_free( const rtems_filesystem_location_info_t *loc )
{
40003e38: 9d e3 bf a0 save %sp, -96, %sp
IMFS_jnode_t *node = loc->node_access;
40003e3c: d0 06 20 08 ld [ %i0 + 8 ], %o0
--node->reference_count;
40003e40: c2 12 20 18 lduh [ %o0 + 0x18 ], %g1
40003e44: 82 00 7f ff add %g1, -1, %g1
40003e48: c2 32 20 18 sth %g1, [ %o0 + 0x18 ]
if ( node->reference_count == 0 ) {
40003e4c: 83 28 60 10 sll %g1, 0x10, %g1
40003e50: 80 a0 60 00 cmp %g1, 0
40003e54: 12 80 00 06 bne 40003e6c <IMFS_node_free+0x34>
<== ALWAYS TAKEN
40003e58: 01 00 00 00 nop
(*node->control->node_destroy)( node );
40003e5c: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
<== NOT EXECUTED
40003e60: c2 00 60 0c ld [ %g1 + 0xc ], %g1
<== NOT EXECUTED
40003e64: 9f c0 40 00 call %g1
<== NOT EXECUTED
40003e68: 01 00 00 00 nop
<== NOT EXECUTED
IMFS_node_destroy( node );
}
}
40003e6c: 81 c7 e0 08 ret
40003e70: 81 e8 00 00 restore
40003e74 <IMFS_node_remove_default>:
IMFS_jnode_t *IMFS_node_remove_default(
IMFS_jnode_t *node
)
{
return node;
}
40003e74: 81 c3 e0 08 retl
<== NOT EXECUTED
40003e78: 01 00 00 00 nop
<== NOT EXECUTED
40002c90 <IMFS_node_remove_directory>:
{
return dir->mt_fs != NULL;
}
IMFS_jnode_t *IMFS_node_remove_directory( IMFS_jnode_t *node )
{
40002c90: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( !rtems_chain_is_empty( &dir->Entries ) ) {
40002c94: c4 06 20 40 ld [ %i0 + 0x40 ], %g2
<== NOT EXECUTED
return &the_chain->Tail.Node;
40002c98: 82 06 20 44 add %i0, 0x44, %g1
<== NOT EXECUTED
40002c9c: 80 a0 80 01 cmp %g2, %g1
<== NOT EXECUTED
40002ca0: 12 80 00 0c bne 40002cd0 <IMFS_node_remove_directory+0x40>
<== NOT EXECUTED
40002ca4: 01 00 00 00 nop
<== NOT EXECUTED
errno = ENOTEMPTY;
dir = NULL;
} else if ( IMFS_is_mount_point( dir ) ) {
40002ca8: c2 06 20 4c ld [ %i0 + 0x4c ], %g1
<== NOT EXECUTED
40002cac: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40002cb0: 02 80 00 0c be 40002ce0 <IMFS_node_remove_directory+0x50>
<== NOT EXECUTED
40002cb4: 01 00 00 00 nop
<== NOT EXECUTED
errno = EBUSY;
40002cb8: 40 00 2f 6d call 4000ea6c <__errno>
<== NOT EXECUTED
40002cbc: b0 10 20 00 clr %i0 ! 0 <PROM_START>
<== NOT EXECUTED
40002cc0: 82 10 20 10 mov 0x10, %g1
<== NOT EXECUTED
40002cc4: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
dir = NULL;
}
return &dir->Node;
}
40002cc8: 81 c7 e0 08 ret
<== NOT EXECUTED
40002ccc: 81 e8 00 00 restore
<== NOT EXECUTED
errno = ENOTEMPTY;
40002cd0: 40 00 2f 67 call 4000ea6c <__errno>
<== NOT EXECUTED
40002cd4: b0 10 20 00 clr %i0
<== NOT EXECUTED
40002cd8: 82 10 20 5a mov 0x5a, %g1
<== NOT EXECUTED
40002cdc: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40002ce0: 81 c7 e0 08 ret
<== NOT EXECUTED
40002ce4: 81 e8 00 00 restore
<== NOT EXECUTED
40004144 <IMFS_readlink>:
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40004144: 80 a2 a0 00 cmp %o2, 0
<== NOT EXECUTED
40004148: 02 80 00 16 be 400041a0 <IMFS_readlink+0x5c>
<== NOT EXECUTED
4000414c: c6 02 20 08 ld [ %o0 + 8 ], %g3
<== NOT EXECUTED
40004150: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
<== NOT EXECUTED
40004154: c4 48 40 00 ldsb [ %g1 ], %g2
<== NOT EXECUTED
40004158: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000415c: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40004160: 12 80 00 07 bne 4000417c <IMFS_readlink+0x38>
<== NOT EXECUTED
40004164: c2 08 40 00 ldub [ %g1 ], %g1
<== NOT EXECUTED
40004168: 30 80 00 0c b,a 40004198 <IMFS_readlink+0x54>
<== NOT EXECUTED
4000416c: c4 48 40 08 ldsb [ %g1 + %o0 ], %g2
<== NOT EXECUTED
40004170: 80 a0 a0 00 cmp %g2, 0
<== NOT EXECUTED
40004174: 02 80 00 07 be 40004190 <IMFS_readlink+0x4c>
<== NOT EXECUTED
40004178: c2 08 40 08 ldub [ %g1 + %o0 ], %g1
<== NOT EXECUTED
buf[i] = sym_link->name[i];
4000417c: c2 2a 40 08 stb %g1, [ %o1 + %o0 ]
<== NOT EXECUTED
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
40004180: 90 02 20 01 inc %o0
<== NOT EXECUTED
40004184: 80 a2 80 08 cmp %o2, %o0
<== NOT EXECUTED
40004188: 32 bf ff f9 bne,a 4000416c <IMFS_readlink+0x28>
<== NOT EXECUTED
4000418c: c2 00 e0 40 ld [ %g3 + 0x40 ], %g1
<== NOT EXECUTED
}
40004190: 81 c3 e0 08 retl
<== NOT EXECUTED
40004194: 01 00 00 00 nop
<== NOT EXECUTED
40004198: 81 c3 e0 08 retl
<== NOT EXECUTED
4000419c: 01 00 00 00 nop
<== NOT EXECUTED
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
400041a0: 81 c3 e0 08 retl
<== NOT EXECUTED
400041a4: 90 10 20 00 clr %o0 ! 0 <PROM_START>
<== NOT EXECUTED
40003ea8 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
40003ea8: 9d e3 bf 90 save %sp, -112, %sp
<== NOT EXECUTED
IMFS_jnode_t *node = oldloc->node_access;
40003eac: fa 06 60 08 ld [ %i1 + 8 ], %i5
<== NOT EXECUTED
/*
* FIXME: Due to insufficient checks we can create inaccessible nodes with
* this operation.
*/
if ( node->Parent == NULL ) {
40003eb0: c2 07 60 08 ld [ %i5 + 8 ], %g1
<== NOT EXECUTED
40003eb4: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40003eb8: 02 80 00 36 be 40003f90 <IMFS_rename+0xe8>
<== NOT EXECUTED
40003ebc: f4 06 a0 08 ld [ %i2 + 8 ], %i2
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( namelen >= IMFS_NAME_MAX ) {
40003ec0: 80 a7 20 fe cmp %i4, 0xfe
<== NOT EXECUTED
40003ec4: 18 80 00 27 bgu 40003f60 <IMFS_rename+0xb8>
<== NOT EXECUTED
40003ec8: 01 00 00 00 nop
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
}
allocated_name = malloc( namelen );
40003ecc: 40 00 02 3c call 400047bc <malloc>
<== NOT EXECUTED
40003ed0: 90 10 00 1c mov %i4, %o0
<== NOT EXECUTED
if ( allocated_name == NULL ) {
40003ed4: b2 92 20 00 orcc %o0, 0, %i1
<== NOT EXECUTED
40003ed8: 02 80 00 28 be 40003f78 <IMFS_rename+0xd0>
<== NOT EXECUTED
40003edc: 94 10 00 1c mov %i4, %o2
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
memcpy( allocated_name, name, namelen );
40003ee0: 40 00 2b 11 call 4000eb24 <memcpy>
<== NOT EXECUTED
40003ee4: 92 10 00 1b mov %i3, %o1
<== NOT EXECUTED
if ( ( node->flags & IMFS_NODE_FLAG_NAME_ALLOCATED ) != 0 ) {
40003ee8: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1
<== NOT EXECUTED
40003eec: 80 88 60 01 btst 1, %g1
<== NOT EXECUTED
40003ef0: 12 80 00 18 bne 40003f50 <IMFS_rename+0xa8>
<== NOT EXECUTED
40003ef4: 01 00 00 00 nop
<== NOT EXECUTED
)
{
Chain_Node *next;
Chain_Node *previous;
next = the_node->next;
40003ef8: c6 07 40 00 ld [ %i5 ], %g3
<== NOT EXECUTED
previous = the_node->previous;
40003efc: c4 07 60 04 ld [ %i5 + 4 ], %g2
<== NOT EXECUTED
free( RTEMS_DECONST( char *, node->name ) );
}
node->name = allocated_name;
40003f00: f2 27 60 0c st %i1, [ %i5 + 0xc ]
<== NOT EXECUTED
node->namelen = namelen;
node->flags |= IMFS_NODE_FLAG_NAME_ALLOCATED;
40003f04: 82 10 60 01 or %g1, 1, %g1
<== NOT EXECUTED
node->namelen = namelen;
40003f08: f8 37 60 10 sth %i4, [ %i5 + 0x10 ]
<== NOT EXECUTED
return &the_chain->Tail.Node;
40003f0c: 88 06 a0 44 add %i2, 0x44, %g4
<== NOT EXECUTED
node->flags |= IMFS_NODE_FLAG_NAME_ALLOCATED;
40003f10: c2 37 60 12 sth %g1, [ %i5 + 0x12 ]
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
40003f14: 90 07 bf f0 add %fp, -16, %o0
<== NOT EXECUTED
next->previous = previous;
40003f18: c4 20 e0 04 st %g2, [ %g3 + 4 ]
<== NOT EXECUTED
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
return 0;
40003f1c: b0 10 20 00 clr %i0
<== NOT EXECUTED
previous->next = next;
40003f20: c6 20 80 00 st %g3, [ %g2 ]
<== NOT EXECUTED
Chain_Node *old_last;
_Assert( _Chain_Is_node_off_chain( the_node ) );
tail = _Chain_Tail( the_chain );
old_last = tail->previous;
40003f24: c2 06 a0 48 ld [ %i2 + 0x48 ], %g1
<== NOT EXECUTED
entry_node->Parent = dir_node;
40003f28: f4 27 60 08 st %i2, [ %i5 + 8 ]
<== NOT EXECUTED
the_node->next = tail;
40003f2c: c8 27 40 00 st %g4, [ %i5 ]
<== NOT EXECUTED
tail->previous = the_node;
40003f30: fa 26 a0 48 st %i5, [ %i2 + 0x48 ]
<== NOT EXECUTED
old_last->next = the_node;
40003f34: fa 20 40 00 st %i5, [ %g1 ]
<== NOT EXECUTED
_Timecounter_Getbintime( &now );
40003f38: 40 00 12 55 call 4000888c <_Timecounter_Getbintime>
<== NOT EXECUTED
40003f3c: c2 27 60 04 st %g1, [ %i5 + 4 ]
<== NOT EXECUTED
return now.sec;
40003f40: c4 1f bf f0 ldd [ %fp + -16 ], %g2
<== NOT EXECUTED
jnode->stat_ctime = _IMFS_get_time();
40003f44: c4 3f 60 30 std %g2, [ %i5 + 0x30 ]
<== NOT EXECUTED
}
40003f48: 81 c7 e0 08 ret
<== NOT EXECUTED
40003f4c: 81 e8 00 00 restore
<== NOT EXECUTED
free( RTEMS_DECONST( char *, node->name ) );
40003f50: 40 00 01 0c call 40004380 <free>
<== NOT EXECUTED
40003f54: d0 07 60 0c ld [ %i5 + 0xc ], %o0
<== NOT EXECUTED
40003f58: 10 bf ff e8 b 40003ef8 <IMFS_rename+0x50>
<== NOT EXECUTED
40003f5c: c2 17 60 12 lduh [ %i5 + 0x12 ], %g1
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
40003f60: 40 00 2a c3 call 4000ea6c <__errno>
<== NOT EXECUTED
40003f64: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40003f68: 82 10 20 5b mov 0x5b, %g1
<== NOT EXECUTED
40003f6c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40003f70: 81 c7 e0 08 ret
<== NOT EXECUTED
40003f74: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
40003f78: 40 00 2a bd call 4000ea6c <__errno>
<== NOT EXECUTED
40003f7c: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40003f80: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40003f84: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40003f88: 81 c7 e0 08 ret
<== NOT EXECUTED
40003f8c: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
40003f90: 40 00 2a b7 call 4000ea6c <__errno>
<== NOT EXECUTED
40003f94: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40003f98: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
40003f9c: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
40003fa0: 81 c7 e0 08 ret
<== NOT EXECUTED
40003fa4: 81 e8 00 00 restore
<== NOT EXECUTED
40003fa8 <IMFS_rmnod>:
int IMFS_rmnod(
const rtems_filesystem_location_info_t *parentloc,
const rtems_filesystem_location_info_t *loc
)
{
40003fa8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int rv = 0;
IMFS_jnode_t *node = loc->node_access;
40003fac: d0 06 60 08 ld [ %i1 + 8 ], %o0
<== NOT EXECUTED
node = (*node->control->node_remove)( node );
40003fb0: c2 02 20 38 ld [ %o0 + 0x38 ], %g1
<== NOT EXECUTED
40003fb4: c2 00 60 08 ld [ %g1 + 8 ], %g1
<== NOT EXECUTED
40003fb8: 9f c0 40 00 call %g1
<== NOT EXECUTED
40003fbc: 01 00 00 00 nop
<== NOT EXECUTED
if ( node != NULL ) {
40003fc0: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
40003fc4: 22 80 00 11 be,a 40004008 <IMFS_rmnod+0x60>
<== NOT EXECUTED
40003fc8: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
--node->reference_count;
40003fcc: c4 12 20 18 lduh [ %o0 + 0x18 ], %g2
<== NOT EXECUTED
--node->st_nlink;
40003fd0: c2 12 20 1a lduh [ %o0 + 0x1a ], %g1
<== NOT EXECUTED
40003fd4: 82 00 7f ff add %g1, -1, %g1
<== NOT EXECUTED
--node->reference_count;
40003fd8: 84 00 bf ff add %g2, -1, %g2
<== NOT EXECUTED
--node->st_nlink;
40003fdc: c2 32 20 1a sth %g1, [ %o0 + 0x1a ]
<== NOT EXECUTED
--node->reference_count;
40003fe0: c4 32 20 18 sth %g2, [ %o0 + 0x18 ]
<== NOT EXECUTED
if ( node->Parent != NULL ) {
40003fe4: c2 02 20 08 ld [ %o0 + 8 ], %g1
<== NOT EXECUTED
40003fe8: 80 a0 60 00 cmp %g1, 0
<== NOT EXECUTED
40003fec: 02 80 00 07 be 40004008 <IMFS_rmnod+0x60>
<== NOT EXECUTED
40003ff0: b0 10 20 00 clr %i0
<== NOT EXECUTED
node->Parent = NULL;
40003ff4: c0 22 20 08 clr [ %o0 + 8 ]
<== NOT EXECUTED
next = the_node->next;
40003ff8: c4 02 00 00 ld [ %o0 ], %g2
<== NOT EXECUTED
previous = the_node->previous;
40003ffc: c2 02 20 04 ld [ %o0 + 4 ], %g1
<== NOT EXECUTED
next->previous = previous;
40004000: c2 20 a0 04 st %g1, [ %g2 + 4 ]
<== NOT EXECUTED
previous->next = next;
40004004: c4 20 40 00 st %g2, [ %g1 ]
<== NOT EXECUTED
40004008: 81 c7 e0 08 ret
<== NOT EXECUTED
4000400c: 81 e8 00 00 restore
<== NOT EXECUTED
} else {
rv = -1;
}
return rv;
}
40004010: 81 c7 e0 08 ret
<== NOT EXECUTED
40004014: 81 e8 00 00 restore
<== NOT EXECUTED
40004018 <IMFS_stat_file>:
struct stat *buf
)
{
const IMFS_file_t *file = loc->node_access;
buf->st_size = file->File.size;
40004018: c2 02 20 08 ld [ %o0 + 8 ], %g1
<== NOT EXECUTED
4000401c: c6 00 60 40 ld [ %g1 + 0x40 ], %g3
<== NOT EXECUTED
buf->st_blksize = imfs_memfile_bytes_per_block;
40004020: 03 10 00 4e sethi %hi(0x40013800), %g1
<== NOT EXECUTED
40004024: c4 00 60 cc ld [ %g1 + 0xcc ], %g2 ! 400138cc <imfs_memfile_bytes_per_block>
<== NOT EXECUTED
buf->st_size = file->File.size;
40004028: c0 22 60 20 clr [ %o1 + 0x20 ]
<== NOT EXECUTED
4000402c: c6 22 60 24 st %g3, [ %o1 + 0x24 ]
<== NOT EXECUTED
buf->st_blksize = imfs_memfile_bytes_per_block;
40004030: c4 22 60 58 st %g2, [ %o1 + 0x58 ]
<== NOT EXECUTED
return IMFS_stat( loc, buf );
40004034: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
40004038: 40 00 00 02 call 40004040 <IMFS_stat>
<== NOT EXECUTED
4000403c: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
400040e0 <IMFS_symlink>:
{
400040e0: 9d e3 bf 98 save %sp, -104, %sp
<== NOT EXECUTED
sizeof( IMFS_sym_link_t ) + strlen( target ) + 1,
400040e4: 40 00 2b b2 call 4000efac <strlen>
<== NOT EXECUTED
400040e8: 90 10 00 1b mov %i3, %o0
<== NOT EXECUTED
new_node = IMFS_create_node(
400040ec: f6 23 a0 5c st %i3, [ %sp + 0x5c ]
<== NOT EXECUTED
400040f0: 94 02 20 49 add %o0, 0x49, %o2
<== NOT EXECUTED
400040f4: 98 10 00 1a mov %i2, %o4
<== NOT EXECUTED
400040f8: 90 10 00 18 mov %i0, %o0
<== NOT EXECUTED
400040fc: 1b 00 00 28 sethi %hi(0xa000), %o5
<== NOT EXECUTED
40004100: 96 10 00 19 mov %i1, %o3
<== NOT EXECUTED
40004104: 9a 13 61 ff or %o5, 0x1ff, %o5
<== NOT EXECUTED
40004108: 13 10 00 41 sethi %hi(0x40010400), %o1
<== NOT EXECUTED
return 0;
4000410c: b0 10 20 00 clr %i0
<== NOT EXECUTED
new_node = IMFS_create_node(
40004110: 40 00 26 3f call 4000da0c <IMFS_create_node>
<== NOT EXECUTED
40004114: 92 12 60 8c or %o1, 0x8c, %o1
<== NOT EXECUTED
if ( new_node == NULL ) {
40004118: 80 a2 20 00 cmp %o0, 0
<== NOT EXECUTED
4000411c: 02 80 00 04 be 4000412c <IMFS_symlink+0x4c>
<== NOT EXECUTED
40004120: 01 00 00 00 nop
<== NOT EXECUTED
}
40004124: 81 c7 e0 08 ret
<== NOT EXECUTED
40004128: 81 e8 00 00 restore
<== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
4000412c: 40 00 2a 50 call 4000ea6c <__errno>
<== NOT EXECUTED
40004130: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
40004134: 82 10 20 0c mov 0xc, %g1
<== NOT EXECUTED
40004138: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
}
4000413c: 81 c7 e0 08 ret
<== NOT EXECUTED
40004140: 81 e8 00 00 restore
<== NOT EXECUTED
400041a8 <IMFS_unmount>:
#endif
#include <rtems/imfs.h>
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
400041a8: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
400041ac: c2 06 20 20 ld [ %i0 + 0x20 ], %g1
<== NOT EXECUTED
400041b0: c4 00 60 08 ld [ %g1 + 8 ], %g2
<== NOT EXECUTED
return S_ISDIR( node->st_mode );
400041b4: 07 00 00 3c sethi %hi(0xf000), %g3
<== NOT EXECUTED
400041b8: c2 00 a0 14 ld [ %g2 + 0x14 ], %g1
<== NOT EXECUTED
400041bc: 82 08 40 03 and %g1, %g3, %g1
<== NOT EXECUTED
if ( IMFS_is_directory( node ) ) {
400041c0: 07 00 00 10 sethi %hi(0x4000), %g3
<== NOT EXECUTED
400041c4: 80 a0 40 03 cmp %g1, %g3
<== NOT EXECUTED
400041c8: 12 80 00 0f bne 40004204 <IMFS_unmount+0x5c>
<== NOT EXECUTED
400041cc: 01 00 00 00 nop
<== NOT EXECUTED
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == mt_entry ) {
400041d0: c2 00 a0 4c ld [ %g2 + 0x4c ], %g1
<== NOT EXECUTED
400041d4: 80 a0 40 18 cmp %g1, %i0
<== NOT EXECUTED
400041d8: 12 80 00 05 bne 400041ec <IMFS_unmount+0x44>
<== NOT EXECUTED
400041dc: 01 00 00 00 nop
<== NOT EXECUTED
dir->mt_fs = NULL;
400041e0: c0 20 a0 4c clr [ %g2 + 0x4c ]
<== NOT EXECUTED
400041e4: 81 c7 e0 08 ret
<== NOT EXECUTED
400041e8: 91 e8 20 00 restore %g0, 0, %o0
<== NOT EXECUTED
} else {
errno = EINVAL;
400041ec: 40 00 2a 20 call 4000ea6c <__errno>
<== NOT EXECUTED
400041f0: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
400041f4: 82 10 20 16 mov 0x16, %g1
<== NOT EXECUTED
400041f8: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
400041fc: 81 c7 e0 08 ret
<== NOT EXECUTED
40004200: 81 e8 00 00 restore
<== NOT EXECUTED
rv = -1;
}
} else {
errno = ENOTDIR;
40004204: 40 00 2a 1a call 4000ea6c <__errno>
<== NOT EXECUTED
40004208: b0 10 3f ff mov -1, %i0
<== NOT EXECUTED
4000420c: 82 10 20 14 mov 0x14, %g1
<== NOT EXECUTED
40004210: c2 22 00 00 st %g1, [ %o0 ]
<== NOT EXECUTED
rv = -1;
}
return rv;
}
40004214: 81 c7 e0 08 ret
<== NOT EXECUTED
40004218: 81 e8 00 00 restore
<== NOT EXECUTED
4000421c <IMFS_utime>:
int IMFS_utime(
const rtems_filesystem_location_info_t *loc,
time_t actime,
time_t modtime
)
{
4000421c: 9d e3 bf a0 save %sp, -96, %sp
<== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = (IMFS_jnode_t *) loc->node_access;
40004220: fa 06 20 08 ld [ %i0 + 8 ], %i5
<== NOT EXECUTED
{
40004224: 84 10 00 1b mov %i3, %g2
<== NOT EXECUTED
40004228: b0 10 00 19 mov %i1, %i0
<== NOT EXECUTED
4000422c: 86 10 00 1c mov %i4, %g3
<== NOT EXECUTED
40004230: b2 10 00 1a mov %i2, %i1
<== NOT EXECUTED
the_jnode->stat_atime = actime;
the_jnode->stat_mtime = modtime;
40004234: c4 3f 60 28 std %g2, [ %i5 + 0x28 ]
<== NOT EXECUTED
the_jnode->stat_ctime = time( NULL );
40004238: 90 10 20 00 clr %o0
<== NOT EXECUTED
the_jnode->stat_atime = actime;
4000423c: f0 3f 60 20 std %i0, [ %i5 + 0x20 ]
<== NOT EXECUTED
the_jnode->stat_ctime = time( NULL );
40004240: 40 00 2b 8b call 4000f06c <time>
<== NOT EXECUTED
40004244: b0 10 20 00 clr %i0
<== NOT EXECUTED
40004248: d0 3f 60 30 std %o0, [ %i5 + 0x30 ]
<== NOT EXECUTED
return 0;
}
4000424c: 81 c7 e0 08 ret
<== NOT EXECUTED
40004250: 81 e8 00 00 restore
<== NOT EXECUTED
4000d9a4 <device_close>:
}
int device_close(
rtems_libio_t *iop
)
{
4000d9a4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_close(
4000d9a8: d4 00 60 44 ld [ %g1 + 0x44 ], %o2
<== NOT EXECUTED
4000d9ac: d2 00 60 40 ld [ %g1 + 0x40 ], %o1
<== NOT EXECUTED
4000d9b0: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000d9b4: 40 00 01 a4 call 4000e044 <rtems_deviceio_close>
<== NOT EXECUTED
4000d9b8: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000da04 <device_ftruncate>:
rtems_libio_t *iop,
off_t length
)
{
return 0;
}
4000da04: 81 c3 e0 08 retl
<== NOT EXECUTED
4000da08: 90 10 20 00 clr %o0
<== NOT EXECUTED
4000d9ec <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
ioctl_command_t command,
void *buffer
)
{
4000d9ec: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_control(
4000d9f0: d8 00 60 44 ld [ %g1 + 0x44 ], %o4
<== NOT EXECUTED
4000d9f4: d6 00 60 40 ld [ %g1 + 0x40 ], %o3
<== NOT EXECUTED
4000d9f8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000d9fc: 40 00 01 d6 call 4000e154 <rtems_deviceio_control>
<== NOT EXECUTED
4000da00: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000d990 <device_open>:
rtems_libio_t *iop,
const char *pathname,
int oflag,
mode_t mode
)
{
4000d990: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_open(
4000d994: d8 18 60 40 ldd [ %g1 + 0x40 ], %o4
<== NOT EXECUTED
4000d998: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000d99c: 40 00 01 9d call 4000e010 <rtems_deviceio_open>
<== NOT EXECUTED
4000d9a0: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000d9bc <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
4000d9bc: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_read(
4000d9c0: d8 00 60 44 ld [ %g1 + 0x44 ], %o4
<== NOT EXECUTED
4000d9c4: d6 00 60 40 ld [ %g1 + 0x40 ], %o3
<== NOT EXECUTED
4000d9c8: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000d9cc: 40 00 01 aa call 4000e074 <rtems_deviceio_read>
<== NOT EXECUTED
4000d9d0: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED
4000d9d4 <device_write>:
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
4000d9d4: c2 02 20 14 ld [ %o0 + 0x14 ], %g1
<== NOT EXECUTED
const IMFS_device_t *device = IMFS_iop_to_device( iop );
return rtems_deviceio_write(
4000d9d8: d8 00 60 44 ld [ %g1 + 0x44 ], %o4
<== NOT EXECUTED
4000d9dc: d6 00 60 40 ld [ %g1 + 0x40 ], %o3
<== NOT EXECUTED
4000d9e0: 82 13 c0 00 mov %o7, %g1
<== NOT EXECUTED
4000d9e4: 40 00 01 c0 call 4000e0e4 <rtems_deviceio_write>
<== NOT EXECUTED
4000d9e8: 9e 10 40 00 mov %g1, %o7
<== NOT EXECUTED