RTEMS-6
Annotated Report
libimfs
Sun Feb 28 23:10:06 2021
00102b10 <IMFS_add_node>:
#endif
#include <rtems/imfs.h>
int IMFS_add_node( const char *path, IMFS_jnode_t *node, void *arg )
{
102b10: 55 push %ebp
102b11: 89 e5 mov %esp,%ebp
102b13: 57 push %edi
102b14: 56 push %esi
102b15: 53 push %ebx
102b16: 83 ec 7c sub $0x7c,%esp
102b19: 8b 7d 0c mov 0xc(%ebp),%edi
rtems_filesystem_eval_path_context_t ctx;
const rtems_filesystem_location_info_t *currentloc;
int eval_flags;
int rv;
mode = node->st_mode;
102b1c: 8b 77 14 mov 0x14(%edi),%esi
mode &= ~rtems_filesystem_umask;
102b1f: e8 cc fc ff ff call 1027f0 <rtems_current_user_env_get>
102b24: 8b 58 08 mov 0x8(%eax),%ebx
102b27: f7 d3 not %ebx
102b29: 21 f3 and %esi,%ebx
switch (mode & S_IFMT) {
102b2b: 89 d8 mov %ebx,%eax
102b2d: 25 00 f0 00 00 and $0xf000,%eax
102b32: 3d 00 60 00 00 cmp $0x6000,%eax
102b37: 74 43 je 102b7c <IMFS_add_node+0x6c> <== NEVER TAKEN
102b39: 76 35 jbe 102b70 <IMFS_add_node+0x60> <== ALWAYS TAKEN
102b3b: 89 d8 mov %ebx,%eax <== NOT EXECUTED
102b3d: 25 00 b0 00 00 and $0xb000,%eax <== NOT EXECUTED
102b42: 3d 00 80 00 00 cmp $0x8000,%eax <== NOT EXECUTED
102b47: 74 33 je 102b7c <IMFS_add_node+0x6c> <== NOT EXECUTED
case S_IFIFO:
case S_IFREG:
case S_IFSOCK:
break;
default:
errno = EINVAL;
102b49: e8 42 65 01 00 call 119090 <__errno>
return -1;
102b4e: bb ff ff ff ff mov $0xffffffff,%ebx
errno = EINVAL;
102b53: c7 00 16 00 00 00 movl $0x16,(%eax)
rv = -1;
}
rtems_filesystem_eval_path_cleanup( &ctx );
return rv;
}
102b59: 83 c4 7c add $0x7c,%esp
102b5c: 89 d8 mov %ebx,%eax
102b5e: 5b pop %ebx
102b5f: 5e pop %esi
102b60: 5f pop %edi
102b61: 5d pop %ebp
102b62: c3 ret
102b63: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
102b6a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
switch (mode & S_IFMT) {
102b70: 2d 00 10 00 00 sub $0x1000,%eax
102b75: a9 00 e0 ff ff test $0xffffe000,%eax
102b7a: 75 cd jne 102b49 <IMFS_add_node+0x39>
currentloc = rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
102b7c: 8b 45 08 mov 0x8(%ebp),%eax
102b7f: 8d 75 b0 lea -0x50(%ebp),%esi
102b82: b9 18 00 00 00 mov $0x18,%ecx
102b87: 89 4c 24 08 mov %ecx,0x8(%esp)
102b8b: 89 34 24 mov %esi,(%esp)
102b8e: 89 44 24 04 mov %eax,0x4(%esp)
102b92: e8 a9 f3 ff ff call 101f40 <rtems_filesystem_eval_path_start>
static inline bool IMFS_is_imfs_instance(
const rtems_filesystem_location_info_t *loc
)
{
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
102b97: 8b 40 14 mov 0x14(%eax),%eax
102b9a: 8b 40 0c mov 0xc(%eax),%eax
if ( IMFS_is_imfs_instance( currentloc ) ) {
102b9d: 81 78 24 d0 43 10 00 cmpl $0x1043d0,0x24(%eax)
102ba4: 74 2a je 102bd0 <IMFS_add_node+0xc0>
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
102ba6: 89 34 24 mov %esi,(%esp)
102ba9: b8 86 00 00 00 mov $0x86,%eax
102bae: 89 44 24 04 mov %eax,0x4(%esp)
102bb2: e8 e9 f3 ff ff call 101fa0 <rtems_filesystem_eval_path_error>
rv = -1;
102bb7: bb ff ff ff ff mov $0xffffffff,%ebx
rtems_filesystem_eval_path_cleanup( &ctx );
102bbc: 89 34 24 mov %esi,(%esp)
102bbf: e8 4c f4 ff ff call 102010 <rtems_filesystem_eval_path_cleanup>
}
102bc4: 83 c4 7c add $0x7c,%esp
102bc7: 89 d8 mov %ebx,%eax
102bc9: 5b pop %ebx
102bca: 5e pop %esi
102bcb: 5f pop %edi
102bcc: 5d pop %ebp
102bcd: c3 ret
102bce: 66 90 xchg %ax,%ax
ctx->flags = flags;
102bd0: c7 45 c0 60 00 00 00 movl $0x60,-0x40(%ebp)
rtems_filesystem_eval_path_set_path( &ctx, node->name, node->namelen );
102bd7: 0f b7 47 10 movzwl 0x10(%edi),%eax
ctx->path = path;
102bdb: 8b 57 0c mov 0xc(%edi),%edx
rtems_filesystem_eval_path_continue( &ctx );
102bde: 89 34 24 mov %esi,(%esp)
ctx->pathlen = pathlen;
102be1: 89 45 b4 mov %eax,-0x4c(%ebp)
ctx->path = path;
102be4: 89 55 b0 mov %edx,-0x50(%ebp)
102be7: e8 b4 f0 ff ff call 101ca0 <rtems_filesystem_eval_path_continue>
return ctx->token;
102bec: 8b 55 b8 mov -0x48(%ebp),%edx
if ( rtems_filesystem_eval_path_get_token( &ctx ) == node->name ) {
102bef: 8b 47 0c mov 0xc(%edi),%eax
102bf2: 39 d0 cmp %edx,%eax
102bf4: 74 2a je 102c20 <IMFS_add_node+0x110>
if ( rtems_filesystem_eval_path_get_token( &ctx ) != NULL ) {
102bf6: 85 d2 test %edx,%edx
102bf8: 74 bd je 102bb7 <IMFS_add_node+0xa7> <== NEVER TAKEN
rtems_filesystem_eval_path_error( &ctx, EINVAL );
102bfa: 89 34 24 mov %esi,(%esp)
102bfd: ba 16 00 00 00 mov $0x16,%edx
rv = -1;
102c02: bb ff ff ff ff mov $0xffffffff,%ebx
rtems_filesystem_eval_path_error( &ctx, EINVAL );
102c07: 89 54 24 04 mov %edx,0x4(%esp)
102c0b: e8 90 f3 ff ff call 101fa0 <rtems_filesystem_eval_path_error>
102c10: eb aa jmp 102bbc <IMFS_add_node+0xac>
102c12: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
102c19: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
node = IMFS_initialize_node(
102c20: 0f b7 57 10 movzwl 0x10(%edi),%edx
102c24: 89 5c 24 10 mov %ebx,0x10(%esp)
102c28: 8b 4d 10 mov 0x10(%ebp),%ecx
102c2b: 89 44 24 08 mov %eax,0x8(%esp)
102c2f: 89 54 24 0c mov %edx,0xc(%esp)
102c33: 89 4c 24 14 mov %ecx,0x14(%esp)
102c37: 8b 47 38 mov 0x38(%edi),%eax
102c3a: 89 3c 24 mov %edi,(%esp)
102c3d: 89 44 24 04 mov %eax,0x4(%esp)
102c41: e8 da 16 00 00 call 104320 <IMFS_initialize_node>
if ( node != NULL ) {
102c46: 85 c0 test %eax,%eax
102c48: 0f 84 69 ff ff ff je 102bb7 <IMFS_add_node+0xa7>
parent = currentloc->node_access;
102c4e: 8b 5d d0 mov -0x30(%ebp),%ebx
IMFS_jnode_t *entry_node
)
{
IMFS_directory_t *dir = (IMFS_directory_t *) dir_node;
entry_node->Parent = dir_node;
102c51: 89 58 08 mov %ebx,0x8(%eax)
old_last = tail->previous;
102c54: 8b 53 44 mov 0x44(%ebx),%edx
return &the_chain->Tail.Node;
102c57: 8d 4b 40 lea 0x40(%ebx),%ecx
102c5a: 89 08 mov %ecx,(%eax)
tail->previous = the_node;
102c5c: 89 43 44 mov %eax,0x44(%ebx)
old_last->next = the_node;
102c5f: 89 02 mov %eax,(%edx)
the_node->previous = old_last;
102c61: 89 50 04 mov %edx,0x4(%eax)
_Timecounter_Getbintime( &now );
102c64: 8d 45 a0 lea -0x60(%ebp),%eax
102c67: 89 04 24 mov %eax,(%esp)
102c6a: e8 81 38 00 00 call 1064f0 <_Timecounter_Getbintime>
return now.sec;
102c6f: 8b 45 a0 mov -0x60(%ebp),%eax
102c72: 8b 55 a4 mov -0x5c(%ebp),%edx
jnode->stat_mtime = now;
102c75: 89 43 28 mov %eax,0x28(%ebx)
102c78: 89 53 2c mov %edx,0x2c(%ebx)
jnode->stat_ctime = now;
102c7b: 89 43 30 mov %eax,0x30(%ebx)
102c7e: 89 53 34 mov %edx,0x34(%ebx)
rv = 0;
102c81: 31 db xor %ebx,%ebx
}
102c83: e9 34 ff ff ff jmp 102bbc <IMFS_add_node+0xac>
102c88: 90 nop
102c89: 90 nop
102c8a: 90 nop
102c8b: 90 nop
102c8c: 90 nop
102c8d: 90 nop
102c8e: 90 nop
102c8f: 90 nop
00104450 <IMFS_do_nothing_destroy>:
void IMFS_do_nothing_destroy( IMFS_jnode_t *node )
{
(void) node;
}
104450: c3 ret <== NOT EXECUTED
104451: 90 nop
104452: 90 nop
104453: 90 nop
104454: 90 nop
104455: 90 nop
104456: 90 nop
104457: 90 nop
104458: 90 nop
104459: 90 nop
10445a: 90 nop
10445b: 90 nop
10445c: 90 nop
10445d: 90 nop
10445e: 90 nop
10445f: 90 nop
00101d20 <IMFS_eval_path_devfs>:
return NULL;
}
void IMFS_eval_path_devfs( rtems_filesystem_eval_path_context_t *ctx )
{
101d20: 55 push %ebp
101d21: b9 f1 ca 11 00 mov $0x11caf1,%ecx
101d26: 89 e5 mov %esp,%ebp
101d28: 57 push %edi
101d29: 56 push %esi
101d2a: 53 push %ebx
101d2b: bb e1 ca 11 00 mov $0x11cae1,%ebx
101d30: 83 ec 2c sub $0x2c,%esp
101d33: 8b 75 08 mov 0x8(%ebp),%esi
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;
101d36: 8b 46 20 mov 0x20(%esi),%eax
return ctx->pathlen;
101d39: 8b 7e 04 mov 0x4(%esi),%edi
101d3c: 89 45 e0 mov %eax,-0x20(%ebp)
return ctx->path;
101d3f: 8b 06 mov (%esi),%eax
101d41: 89 45 e4 mov %eax,-0x1c(%ebp)
return ctx->pathlen;
101d44: b8 01 00 00 00 mov $0x1,%eax
&& memcmp( IMFS_devfs_dirs[ i ].name, path, pathlen ) == 0;
101d49: 39 c7 cmp %eax,%edi
101d4b: 74 0f je 101d5c <IMFS_eval_path_devfs+0x3c> <== NEVER TAKEN
for ( i = 0; i < RTEMS_ARRAY_SIZE( IMFS_devfs_dirs ); ++i ) {
101d4d: 83 c3 04 add $0x4,%ebx
101d50: 39 d9 cmp %ebx,%ecx
101d52: 74 5c je 101db0 <IMFS_eval_path_devfs+0x90>
match = IMFS_devfs_dirs[ i ].len == pathlen
101d54: 0f b6 43 ff movzbl -0x1(%ebx),%eax
&& memcmp( IMFS_devfs_dirs[ i ].name, path, pathlen ) == 0;
101d58: 39 c7 cmp %eax,%edi
101d5a: 75 f1 jne 101d4d <IMFS_eval_path_devfs+0x2d>
101d5c: 89 7c 24 08 mov %edi,0x8(%esp)
101d60: 8b 45 e4 mov -0x1c(%ebp),%eax
101d63: 89 1c 24 mov %ebx,(%esp)
101d66: 89 44 24 04 mov %eax,0x4(%esp)
101d6a: e8 f0 3f 01 00 call 115d5f <memcmp>
101d6f: 85 c0 test %eax,%eax
101d71: 75 2d jne 101da0 <IMFS_eval_path_devfs+0x80> <== NEVER TAKEN
ctx->pathlen = 0;
101d73: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
entry = IMFS_devfs_is_dir( ctx, dir );
if ( entry != NULL ) {
101d7a: 8b 45 e0 mov -0x20(%ebp),%eax
eval_flags &= ~RTEMS_FS_EXCLUSIVE;
101d7d: 83 66 10 bf andl $0xffffffbf,0x10(%esi)
if ( entry != NULL ) {
101d81: 85 c0 test %eax,%eax
101d83: 0f 84 df 00 00 00 je 101e68 <IMFS_eval_path_devfs+0x148> <== NEVER TAKEN
rtems_filesystem_eval_path_get_path( ctx ),
rtems_filesystem_eval_path_get_pathlen( ctx )
);
rtems_filesystem_eval_path_clear_path( ctx );
}
}
101d89: 83 c4 2c add $0x2c,%esp
101d8c: 5b pop %ebx
101d8d: 5e pop %esi
101d8e: 5f pop %edi
101d8f: 5d pop %ebp
101d90: c3 ret
101d91: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101d98: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101d9f: 90 nop
101da0: b9 f1 ca 11 00 mov $0x11caf1,%ecx <== NOT EXECUTED
for ( i = 0; i < RTEMS_ARRAY_SIZE( IMFS_devfs_dirs ); ++i ) {
101da5: 83 c3 04 add $0x4,%ebx <== NOT EXECUTED
101da8: 39 d9 cmp %ebx,%ecx <== NOT EXECUTED
101daa: 75 a8 jne 101d54 <IMFS_eval_path_devfs+0x34> <== NOT EXECUTED
101dac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
return _Chain_Immutable_head( the_chain )->next;
101db0: 8b 45 e0 mov -0x20(%ebp),%eax
101db3: 8b 58 3c mov 0x3c(%eax),%ebx
return &the_chain->Tail.Node;
101db6: 8d 48 40 lea 0x40(%eax),%ecx
while ( current != tail ) {
101db9: 39 cb cmp %ecx,%ebx
101dbb: 0f 84 92 00 00 00 je 101e53 <IMFS_eval_path_devfs+0x133> <== NEVER TAKEN
101dc1: 89 75 08 mov %esi,0x8(%ebp)
101dc4: 89 ce mov %ecx,%esi
101dc6: eb 0e jmp 101dd6 <IMFS_eval_path_devfs+0xb6>
101dc8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
101dcf: 90 nop
return the_node->next;
101dd0: 8b 1b mov (%ebx),%ebx
101dd2: 39 de cmp %ebx,%esi
101dd4: 74 7a je 101e50 <IMFS_eval_path_devfs+0x130>
match = entry->namelen == pathlen
101dd6: 0f b7 43 10 movzwl 0x10(%ebx),%eax
&& memcmp( entry->name, path, pathlen ) == 0;
101dda: 39 f8 cmp %edi,%eax
101ddc: 75 f2 jne 101dd0 <IMFS_eval_path_devfs+0xb0>
101dde: 89 7c 24 08 mov %edi,0x8(%esp)
101de2: 8b 45 e4 mov -0x1c(%ebp),%eax
101de5: 89 44 24 04 mov %eax,0x4(%esp)
101de9: 8b 43 0c mov 0xc(%ebx),%eax
101dec: 89 04 24 mov %eax,(%esp)
101def: e8 6b 3f 01 00 call 115d5f <memcmp>
101df4: 85 c0 test %eax,%eax
101df6: 75 d8 jne 101dd0 <IMFS_eval_path_devfs+0xb0>
if ( ( eval_flags & RTEMS_FS_EXCLUSIVE ) == 0 ) {
101df8: 8b 75 08 mov 0x8(%ebp),%esi
101dfb: f6 46 10 40 testb $0x40,0x10(%esi)
101dff: 75 2f jne 101e30 <IMFS_eval_path_devfs+0x110> <== NEVER TAKEN
--dir->Node.reference_count;
101e01: 8b 45 e0 mov -0x20(%ebp),%eax
101e04: 66 ff 48 18 decw 0x18(%eax)
currentloc->node_access_2 = IMFS_generic_get_context_by_node( entry );
101e08: 8b 43 3c mov 0x3c(%ebx),%eax
++entry->reference_count;
101e0b: 66 ff 43 18 incw 0x18(%ebx)
currentloc->node_access_2 = IMFS_generic_get_context_by_node( entry );
101e0f: 89 46 24 mov %eax,0x24(%esi)
loc->handlers = node->control->handlers;
101e12: 8b 43 38 mov 0x38(%ebx),%eax
currentloc->node_access = entry;
101e15: 89 5e 20 mov %ebx,0x20(%esi)
101e18: 8b 00 mov (%eax),%eax
101e1a: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
101e21: 89 46 28 mov %eax,0x28(%esi)
}
101e24: 83 c4 2c add $0x2c,%esp
101e27: 5b pop %ebx
101e28: 5e pop %esi
101e29: 5f pop %edi
101e2a: 5d pop %ebp
101e2b: c3 ret
101e2c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
rtems_filesystem_eval_path_error( ctx, EEXIST );
101e30: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
101e33: ba 11 00 00 00 mov $0x11,%edx <== NOT EXECUTED
101e38: 89 54 24 04 mov %edx,0x4(%esp) <== NOT EXECUTED
101e3c: e8 4f f2 ff ff call 101090 <rtems_filesystem_eval_path_error> <== NOT EXECUTED
101e41: e9 43 ff ff ff jmp 101d89 <IMFS_eval_path_devfs+0x69> <== NOT EXECUTED
101e46: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
101e4d: 8d 76 00 lea 0x0(%esi),%esi <== NOT EXECUTED
101e50: 8b 75 08 mov 0x8(%ebp),%esi
ctx->tokenlen = tokenlen;
101e53: 89 7e 0c mov %edi,0xc(%esi)
ctx->token = token;
101e56: 8b 45 e4 mov -0x1c(%ebp),%eax
ctx->pathlen = 0;
101e59: c7 46 04 00 00 00 00 movl $0x0,0x4(%esi)
ctx->token = token;
101e60: 89 46 08 mov %eax,0x8(%esi)
}
101e63: e9 21 ff ff ff jmp 101d89 <IMFS_eval_path_devfs+0x69>
101e68: 31 ff xor %edi,%edi <== NOT EXECUTED
101e6a: e9 41 ff ff ff jmp 101db0 <IMFS_eval_path_devfs+0x90> <== NOT EXECUTED
101e6f: 90 nop
001080e0 <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
)
{
1080e0: 55 push %ebp
1080e1: 89 e5 mov %esp,%ebp
1080e3: 57 push %edi
1080e4: 56 push %esi
1080e5: 53 push %ebx
1080e6: 83 ec 3c sub $0x3c,%esp
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
loc = temp_mt_entry->mt_fs_root->location;
1080e9: 8b 45 08 mov 0x8(%ebp),%eax
1080ec: 8b 48 24 mov 0x24(%eax),%ecx
1080ef: 31 c0 xor %eax,%eax
1080f1: 8b 14 01 mov (%ecx,%eax,1),%edx
1080f4: 89 54 05 d0 mov %edx,-0x30(%ebp,%eax,1)
1080f8: 83 c0 04 add $0x4,%eax
1080fb: 83 f8 18 cmp $0x18,%eax
1080fe: 72 f1 jb 1080f1 <IMFS_fsunmount+0x11>
jnode = (IMFS_jnode_t *)loc.node_access;
108100: 8b 5d d8 mov -0x28(%ebp),%ebx
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
result = IMFS_rmnod( NULL, &loc );
108103: 8d 75 d0 lea -0x30(%ebp),%esi
return S_ISDIR( node->st_mode );
108106: 8b 43 14 mov 0x14(%ebx),%eax
108109: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
loc->handlers = node->control->handlers;
108110: 8b 53 38 mov 0x38(%ebx),%edx
return S_ISDIR( node->st_mode );
108113: 25 00 f0 00 00 and $0xf000,%eax
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
108118: 3d 00 40 00 00 cmp $0x4000,%eax
next = jnode->Parent;
10811d: 8b 7b 08 mov 0x8(%ebx),%edi
loc.node_access = (void *)jnode;
108120: 89 5d d8 mov %ebx,-0x28(%ebp)
loc->handlers = node->control->handlers;
108123: 8b 12 mov (%edx),%edx
108125: 89 55 e0 mov %edx,-0x20(%ebp)
if ( !IMFS_is_directory( jnode ) || jnode_has_no_children( jnode ) ) {
108128: 75 26 jne 108150 <IMFS_fsunmount+0x70>
return _Chain_Immutable_head( the_chain )->next;
10812a: 8b 53 3c mov 0x3c(%ebx),%edx
return &the_chain->Tail.Node;
10812d: 8d 43 40 lea 0x40(%ebx),%eax
108130: 39 c2 cmp %eax,%edx
108132: 74 1c je 108150 <IMFS_fsunmount+0x70>
if ( IMFS_is_directory( jnode ) ) {
if ( jnode_has_children( jnode ) )
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
108134: 85 d2 test %edx,%edx
108136: 74 68 je 1081a0 <IMFS_fsunmount+0xc0> <== NEVER TAKEN
return S_ISDIR( node->st_mode );
108138: 8b 42 14 mov 0x14(%edx),%eax
10813b: 89 d7 mov %edx,%edi
10813d: 89 fb mov %edi,%ebx
10813f: eb cf jmp 108110 <IMFS_fsunmount+0x30>
108141: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
108148: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10814f: 90 nop
result = IMFS_rmnod( NULL, &loc );
108150: 89 74 24 04 mov %esi,0x4(%esp)
108154: c7 04 24 00 00 00 00 movl $0x0,(%esp)
10815b: e8 e0 c0 ff ff call 104240 <IMFS_rmnod>
if ( result != 0 )
108160: 85 c0 test %eax,%eax
108162: 75 44 jne 1081a8 <IMFS_fsunmount+0xc8> <== NEVER TAKEN
IMFS_node_destroy( jnode );
108164: 89 1c 24 mov %ebx,(%esp)
108167: e8 b4 be ff ff call 104020 <IMFS_node_destroy>
if ( jnode != NULL ) {
10816c: 85 ff test %edi,%edi
10816e: 74 30 je 1081a0 <IMFS_fsunmount+0xc0>
108170: 8b 47 14 mov 0x14(%edi),%eax
108173: 89 c2 mov %eax,%edx
108175: 81 e2 00 f0 00 00 and $0xf000,%edx
if ( IMFS_is_directory( jnode ) ) {
10817b: 81 fa 00 40 00 00 cmp $0x4000,%edx
108181: 75 ba jne 10813d <IMFS_fsunmount+0x5d> <== NEVER TAKEN
return _Chain_Immutable_head( the_chain )->next;
108183: 8b 57 3c mov 0x3c(%edi),%edx
return &the_chain->Tail.Node;
108186: 8d 4f 40 lea 0x40(%edi),%ecx
if ( jnode_has_children( jnode ) )
108189: 39 ca cmp %ecx,%edx
10818b: 75 a7 jne 108134 <IMFS_fsunmount+0x54>
10818d: 89 fb mov %edi,%ebx
10818f: e9 7c ff ff ff jmp 108110 <IMFS_fsunmount+0x30>
108194: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10819b: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
10819f: 90 nop
}
1081a0: 83 c4 3c add $0x3c,%esp
1081a3: 5b pop %ebx
1081a4: 5e pop %esi
1081a5: 5f pop %edi
1081a6: 5d pop %ebp
1081a7: c3 ret
rtems_fatal_error_occurred( 0xdeadbeef );
1081a8: c7 04 24 ef be ad de movl $0xdeadbeef,(%esp) <== NOT EXECUTED
1081af: e8 dc c4 ff ff call 104690 <rtems_fatal_error_occurred> <== NOT EXECUTED
1081b4: 90 nop
1081b5: 90 nop
1081b6: 90 nop
1081b7: 90 nop
1081b8: 90 nop
1081b9: 90 nop
1081ba: 90 nop
1081bb: 90 nop
1081bc: 90 nop
1081bd: 90 nop
1081be: 90 nop
1081bf: 90 nop
00104320 <IMFS_initialize_node>:
const char *name,
size_t namelen,
mode_t mode,
void *arg
)
{
104320: 55 push %ebp
104321: 89 e5 mov %esp,%ebp
104323: 83 ec 38 sub $0x38,%esp
104326: 8b 45 14 mov 0x14(%ebp),%eax
104329: 89 5d f4 mov %ebx,-0xc(%ebp)
10432c: 8b 4d 10 mov 0x10(%ebp),%ecx
10432f: 89 75 f8 mov %esi,-0x8(%ebp)
104332: 8b 5d 08 mov 0x8(%ebp),%ebx
104335: 89 7d fc mov %edi,-0x4(%ebp)
104338: 8b 75 0c mov 0xc(%ebp),%esi
time_t now;
if ( namelen > IMFS_NAME_MAX ) {
10433b: 3d ff 00 00 00 cmp $0xff,%eax
{
104340: 8b 55 18 mov 0x18(%ebp),%edx
104343: 8b 7d 1c mov 0x1c(%ebp),%edi
if ( namelen > IMFS_NAME_MAX ) {
104346: 77 68 ja 1043b0 <IMFS_initialize_node+0x90>
node->control = node_control;
/*
* Fill in the mode and permission information for the jnode structure.
*/
node->st_mode = mode;
104348: 89 53 14 mov %edx,0x14(%ebx)
node->name = name;
10434b: 89 4b 0c mov %ecx,0xc(%ebx)
node->control = node_control;
10434e: 89 73 38 mov %esi,0x38(%ebx)
node->namelen = namelen;
104351: 66 89 43 10 mov %ax,0x10(%ebx)
node->reference_count = 1;
104355: c7 43 18 01 00 01 00 movl $0x10001,0x18(%ebx)
node->st_uid = geteuid();
10435c: e8 6f 55 00 00 call 1098d0 <geteuid>
104361: 66 89 43 1c mov %ax,0x1c(%ebx)
node->st_gid = getegid();
104365: e8 46 55 00 00 call 1098b0 <getegid>
10436a: 66 89 43 1e mov %ax,0x1e(%ebx)
_Timecounter_Getbintime( &now );
10436e: 8d 45 d8 lea -0x28(%ebp),%eax
104371: 89 04 24 mov %eax,(%esp)
104374: e8 77 21 00 00 call 1064f0 <_Timecounter_Getbintime>
return now.sec;
104379: 8b 45 d8 mov -0x28(%ebp),%eax
10437c: 8b 55 dc mov -0x24(%ebp),%edx
/*
* Now set all the times.
*/
now = _IMFS_get_time();
node->stat_atime = now;
10437f: 89 43 20 mov %eax,0x20(%ebx)
node->stat_mtime = now;
104382: 89 43 28 mov %eax,0x28(%ebx)
node->stat_ctime = now;
104385: 89 43 30 mov %eax,0x30(%ebx)
node->stat_atime = now;
104388: 89 53 24 mov %edx,0x24(%ebx)
node->stat_mtime = now;
10438b: 89 53 2c mov %edx,0x2c(%ebx)
node->stat_ctime = now;
10438e: 89 53 34 mov %edx,0x34(%ebx)
return (*node_control->node_initialize)( node, arg );
104391: 89 7d 0c mov %edi,0xc(%ebp)
}
104394: 8b 7d fc mov -0x4(%ebp),%edi
return (*node_control->node_initialize)( node, arg );
104397: 89 5d 08 mov %ebx,0x8(%ebp)
}
10439a: 8b 5d f4 mov -0xc(%ebp),%ebx
return (*node_control->node_initialize)( node, arg );
10439d: 8b 46 04 mov 0x4(%esi),%eax
}
1043a0: 8b 75 f8 mov -0x8(%ebp),%esi
1043a3: 89 ec mov %ebp,%esp
1043a5: 5d pop %ebp
return (*node_control->node_initialize)( node, arg );
1043a6: ff e0 jmp *%eax
1043a8: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1043af: 90 nop
errno = ENAMETOOLONG;
1043b0: e8 db 4c 01 00 call 119090 <__errno>
}
1043b5: 8b 5d f4 mov -0xc(%ebp),%ebx <== NOT EXECUTED
1043b8: 8b 75 f8 mov -0x8(%ebp),%esi <== NOT EXECUTED
1043bb: 8b 7d fc mov -0x4(%ebp),%edi <== NOT EXECUTED
errno = ENAMETOOLONG;
1043be: c7 00 5b 00 00 00 movl $0x5b,(%eax) <== NOT EXECUTED
}
1043c4: 89 ec mov %ebp,%esp <== NOT EXECUTED
1043c6: 31 c0 xor %eax,%eax <== NOT EXECUTED
1043c8: 5d pop %ebp <== NOT EXECUTED
1043c9: c3 ret <== NOT EXECUTED
1043ca: 90 nop
1043cb: 90 nop
1043cc: 90 nop
1043cd: 90 nop
1043ce: 90 nop
1043cf: 90 nop
00106860 <IMFS_make_node>:
mode_t mode,
const IMFS_node_control *node_control,
size_t node_size,
void *context
)
{
106860: 55 push %ebp
106861: 89 e5 mov %esp,%ebp
106863: 57 push %edi
106864: 56 push %esi
106865: 53 push %ebx
106866: 83 ec 7c sub $0x7c,%esp
int rv = 0;
mode &= ~rtems_filesystem_umask;
106869: e8 e2 f1 ff ff call 105a50 <rtems_current_user_env_get>
10686e: 8b 4d 0c mov 0xc(%ebp),%ecx
106871: 8b 58 08 mov 0x8(%eax),%ebx
106874: f7 d3 not %ebx
106876: 21 cb and %ecx,%ebx
switch (mode & S_IFMT) {
106878: 89 d8 mov %ebx,%eax
10687a: 25 00 f0 00 00 and $0xf000,%eax
10687f: 3d 00 60 00 00 cmp $0x6000,%eax
106884: 74 36 je 1068bc <IMFS_make_node+0x5c>
106886: 76 28 jbe 1068b0 <IMFS_make_node+0x50>
106888: 89 d8 mov %ebx,%eax
10688a: 25 00 b0 00 00 and $0xb000,%eax
10688f: 3d 00 80 00 00 cmp $0x8000,%eax
106894: 74 26 je 1068bc <IMFS_make_node+0x5c> <== ALWAYS TAKEN
case S_IFIFO:
case S_IFREG:
case S_IFSOCK:
break;
default:
errno = EINVAL;
106896: e8 b5 8a 01 00 call 11f350 <__errno>
rv = -1;
10689b: bb ff ff ff ff mov $0xffffffff,%ebx
errno = EINVAL;
1068a0: c7 00 16 00 00 00 movl $0x16,(%eax)
rtems_filesystem_eval_path_cleanup( &ctx );
}
return rv;
}
1068a6: 83 c4 7c add $0x7c,%esp
1068a9: 89 d8 mov %ebx,%eax
1068ab: 5b pop %ebx
1068ac: 5e pop %esi
1068ad: 5f pop %edi
1068ae: 5d pop %ebp
1068af: c3 ret
switch (mode & S_IFMT) {
1068b0: 2d 00 10 00 00 sub $0x1000,%eax
1068b5: a9 00 e0 ff ff test $0xffffe000,%eax
1068ba: 75 da jne 106896 <IMFS_make_node+0x36>
rtems_filesystem_eval_path_start( &ctx, path, eval_flags );
1068bc: 8b 45 08 mov 0x8(%ebp),%eax
1068bf: 8d 7d b0 lea -0x50(%ebp),%edi
1068c2: ba 78 00 00 00 mov $0x78,%edx
1068c7: 89 54 24 08 mov %edx,0x8(%esp)
1068cb: 89 3c 24 mov %edi,(%esp)
1068ce: 89 44 24 04 mov %eax,0x4(%esp)
1068d2: e8 19 e7 ff ff call 104ff0 <rtems_filesystem_eval_path_start>
1068d7: 89 c6 mov %eax,%esi
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
1068d9: 8b 40 14 mov 0x14(%eax),%eax
1068dc: 8b 40 0c mov 0xc(%eax),%eax
if ( IMFS_is_imfs_instance( currentloc ) ) {
1068df: 81 78 24 c0 78 10 00 cmpl $0x1078c0,0x24(%eax)
1068e6: 74 28 je 106910 <IMFS_make_node+0xb0>
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
1068e8: 89 3c 24 mov %edi,(%esp)
1068eb: b8 86 00 00 00 mov $0x86,%eax
rv = -1;
1068f0: bb ff ff ff ff mov $0xffffffff,%ebx
rtems_filesystem_eval_path_error( &ctx, ENOTSUP );
1068f5: 89 44 24 04 mov %eax,0x4(%esp)
1068f9: e8 32 e8 ff ff call 105130 <rtems_filesystem_eval_path_error>
rtems_filesystem_eval_path_cleanup( &ctx );
1068fe: 89 3c 24 mov %edi,(%esp)
106901: e8 9a e8 ff ff call 1051a0 <rtems_filesystem_eval_path_cleanup>
}
106906: 83 c4 7c add $0x7c,%esp
106909: 89 d8 mov %ebx,%eax
10690b: 5b pop %ebx
10690c: 5e pop %esi
10690d: 5f pop %edi
10690e: 5d pop %ebp
10690f: c3 ret
IMFS_jnode_t *new_node = IMFS_create_node(
106910: 89 5c 24 14 mov %ebx,0x14(%esp)
106914: 8b 45 18 mov 0x18(%ebp),%eax
rv = -1;
106917: bb ff ff ff ff mov $0xffffffff,%ebx
IMFS_jnode_t *new_node = IMFS_create_node(
10691c: 89 34 24 mov %esi,(%esp)
10691f: 89 44 24 18 mov %eax,0x18(%esp)
106923: 8b 45 bc mov -0x44(%ebp),%eax
106926: 89 44 24 10 mov %eax,0x10(%esp)
10692a: 8b 45 b8 mov -0x48(%ebp),%eax
10692d: 89 44 24 0c mov %eax,0xc(%esp)
106931: 8b 45 14 mov 0x14(%ebp),%eax
106934: 89 44 24 08 mov %eax,0x8(%esp)
106938: 8b 45 10 mov 0x10(%ebp),%eax
10693b: 89 44 24 04 mov %eax,0x4(%esp)
10693f: e8 4c a1 00 00 call 110a90 <IMFS_create_node>
if ( new_node != NULL ) {
106944: 85 c0 test %eax,%eax
106946: 74 b6 je 1068fe <IMFS_make_node+0x9e>
_Timecounter_Getbintime( &now );
106948: 8d 45 a0 lea -0x60(%ebp),%eax
IMFS_jnode_t *parent = currentloc->node_access;
10694b: 8b 5e 08 mov 0x8(%esi),%ebx
10694e: 89 04 24 mov %eax,(%esp)
106951: e8 7a 33 00 00 call 109cd0 <_Timecounter_Getbintime>
return now.sec;
106956: 8b 45 a0 mov -0x60(%ebp),%eax
106959: 8b 55 a4 mov -0x5c(%ebp),%edx
jnode->stat_mtime = now;
10695c: 89 43 28 mov %eax,0x28(%ebx)
10695f: 89 53 2c mov %edx,0x2c(%ebx)
jnode->stat_ctime = now;
106962: 89 43 30 mov %eax,0x30(%ebx)
106965: 89 53 34 mov %edx,0x34(%ebx)
int rv = 0;
106968: 31 db xor %ebx,%ebx
}
10696a: eb 92 jmp 1068fe <IMFS_make_node+0x9e>
10696c: 90 nop
10696d: 90 nop
10696e: 90 nop
10696f: 90 nop
00103e50 <IMFS_memfile_write>:
{
103e50: 55 push %ebp
103e51: 89 e5 mov %esp,%ebp
103e53: 57 push %edi
103e54: 56 push %esi
103e55: 53 push %ebx
103e56: 83 ec 4c sub $0x4c,%esp
if ( last_byte > memfile->File.size ) {
103e59: 8b 45 08 mov 0x8(%ebp),%eax
{
103e5c: 8b 7d 0c mov 0xc(%ebp),%edi
last_byte = start + my_length;
103e5f: 8b 55 18 mov 0x18(%ebp),%edx
{
103e62: 8b 75 10 mov 0x10(%ebp),%esi
if ( last_byte > memfile->File.size ) {
103e65: 8b 40 3c mov 0x3c(%eax),%eax
last_byte = start + my_length;
103e68: 01 fa add %edi,%edx
if ( last_byte > memfile->File.size ) {
103e6a: 39 d0 cmp %edx,%eax
103e6c: 0f 82 1e 01 00 00 jb 103f90 <IMFS_memfile_write+0x140>
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
103e72: 89 3c 24 mov %edi,(%esp)
103e75: 8b 1d 4c 48 12 00 mov 0x12484c,%ebx
103e7b: 8d 45 d0 lea -0x30(%ebp),%eax
103e7e: 89 44 24 10 mov %eax,0x10(%esp)
103e82: 89 74 24 04 mov %esi,0x4(%esp)
103e86: 89 5c 24 08 mov %ebx,0x8(%esp)
103e8a: 89 d8 mov %ebx,%eax
103e8c: c1 f8 1f sar $0x1f,%eax
103e8f: 89 44 24 0c mov %eax,0xc(%esp)
103e93: e8 68 3d 01 00 call 117c00 <__divmoddi4>
103e98: 8b 7d d0 mov -0x30(%ebp),%edi
if ( start_offset ) {
103e9b: 85 ff test %edi,%edi
103e9d: 89 c2 mov %eax,%edx
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
103e9f: 89 c6 mov %eax,%esi
if ( start_offset ) {
103ea1: 0f 85 29 01 00 00 jne 103fd0 <IMFS_memfile_write+0x180>
copied = 0;
103ea7: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp)
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
103eae: 39 5d 18 cmp %ebx,0x18(%ebp)
103eb1: 72 7f jb 103f32 <IMFS_memfile_write+0xe2>
103eb3: 89 f2 mov %esi,%edx
103eb5: eb 1a jmp 103ed1 <IMFS_memfile_write+0x81>
103eb7: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
103ebe: 66 90 xchg %ax,%ax
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
103ec0: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
103ec2: 42 inc %edx
my_length -= to_copy;
103ec3: 29 5d 18 sub %ebx,0x18(%ebp)
src += to_copy;
103ec6: 01 5d 14 add %ebx,0x14(%ebp)
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
103ec9: 01 5d c8 add %ebx,-0x38(%ebp)
103ecc: 3b 5d 18 cmp 0x18(%ebp),%ebx
103ecf: 77 5f ja 103f30 <IMFS_memfile_write+0xe0>
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
103ed1: 89 55 cc mov %edx,-0x34(%ebp)
103ed4: 8b 45 08 mov 0x8(%ebp),%eax
103ed7: 31 c9 xor %ecx,%ecx
103ed9: e8 72 f7 ff ff call 103650 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
103ede: 85 c0 test %eax,%eax
103ee0: 0f 84 9c 00 00 00 je 103f82 <IMFS_memfile_write+0x132> <== NEVER TAKEN
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
103ee6: 8b 00 mov (%eax),%eax
103ee8: 83 fb 08 cmp $0x8,%ebx
103eeb: 89 d9 mov %ebx,%ecx
103eed: 8b 75 14 mov 0x14(%ebp),%esi
103ef0: 8b 55 cc mov -0x34(%ebp),%edx
103ef3: 89 c7 mov %eax,%edi
103ef5: 72 c9 jb 103ec0 <IMFS_memfile_write+0x70> <== NEVER TAKEN
103ef7: a8 01 test $0x1,%al
103ef9: 0f 85 41 01 00 00 jne 104040 <IMFS_memfile_write+0x1f0> <== NEVER TAKEN
103eff: f7 c7 02 00 00 00 test $0x2,%edi
103f05: 0f 85 15 01 00 00 jne 104020 <IMFS_memfile_write+0x1d0> <== NEVER TAKEN
103f0b: f7 c7 04 00 00 00 test $0x4,%edi
103f11: 74 ad je 103ec0 <IMFS_memfile_write+0x70>
103f13: 8b 06 mov (%esi),%eax
103f15: 83 c7 04 add $0x4,%edi
103f18: 83 c6 04 add $0x4,%esi
103f1b: 83 e9 04 sub $0x4,%ecx
103f1e: 89 47 fc mov %eax,-0x4(%edi)
103f21: eb 9d jmp 103ec0 <IMFS_memfile_write+0x70>
103f23: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
103f2a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
103f30: 89 d6 mov %edx,%esi
if ( my_length ) {
103f32: 8b 45 18 mov 0x18(%ebp),%eax
103f35: 85 c0 test %eax,%eax
103f37: 74 29 je 103f62 <IMFS_memfile_write+0x112>
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
103f39: 8b 45 08 mov 0x8(%ebp),%eax
103f3c: 31 c9 xor %ecx,%ecx
103f3e: 89 f2 mov %esi,%edx
103f40: e8 0b f7 ff ff call 103650 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
103f45: 85 c0 test %eax,%eax
103f47: 74 39 je 103f82 <IMFS_memfile_write+0x132> <== NEVER TAKEN
memcpy( &(*block_ptr)[ 0 ], src, my_length );
103f49: 8b 4d 18 mov 0x18(%ebp),%ecx
103f4c: 8b 38 mov (%eax),%edi
103f4e: 8b 75 14 mov 0x14(%ebp),%esi
103f51: 83 f9 08 cmp $0x8,%ecx
103f54: 0f 83 72 01 00 00 jae 1040cc <IMFS_memfile_write+0x27c>
103f5a: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
copied += to_copy;
103f5c: 8b 75 18 mov 0x18(%ebp),%esi
103f5f: 01 75 c8 add %esi,-0x38(%ebp)
_Timecounter_Getbintime( &now );
103f62: 8d 45 d8 lea -0x28(%ebp),%eax
103f65: 89 04 24 mov %eax,(%esp)
103f68: e8 83 25 00 00 call 1064f0 <_Timecounter_Getbintime>
jnode->stat_mtime = now;
103f6d: 8b 75 08 mov 0x8(%ebp),%esi
return now.sec;
103f70: 8b 45 d8 mov -0x28(%ebp),%eax
103f73: 8b 55 dc mov -0x24(%ebp),%edx
jnode->stat_mtime = now;
103f76: 89 46 28 mov %eax,0x28(%esi)
103f79: 89 56 2c mov %edx,0x2c(%esi)
jnode->stat_ctime = now;
103f7c: 89 46 30 mov %eax,0x30(%esi)
103f7f: 89 56 34 mov %edx,0x34(%esi)
}
103f82: 8b 45 c8 mov -0x38(%ebp),%eax
103f85: 83 c4 4c add $0x4c,%esp
103f88: 5b pop %ebx
103f89: 5e pop %esi
103f8a: 5f pop %edi
103f8b: 5d pop %ebp
103f8c: c3 ret
103f8d: 8d 76 00 lea 0x0(%esi),%esi
bool zero_fill = start > memfile->File.size;
103f90: c7 45 cc 01 00 00 00 movl $0x1,-0x34(%ebp)
103f97: 31 db xor %ebx,%ebx
103f99: 39 f8 cmp %edi,%eax
103f9b: 89 d8 mov %ebx,%eax
103f9d: 19 f0 sbb %esi,%eax
103f9f: 0f 8d bb 00 00 00 jge 104060 <IMFS_memfile_write+0x210>
status = IMFS_memfile_extend( memfile, zero_fill, last_byte );
103fa5: 89 14 24 mov %edx,(%esp)
103fa8: 8b 45 08 mov 0x8(%ebp),%eax
103fab: 31 db xor %ebx,%ebx
103fad: 89 5c 24 04 mov %ebx,0x4(%esp)
103fb1: 8b 55 cc mov -0x34(%ebp),%edx
103fb4: e8 f7 f8 ff ff call 1038b0 <IMFS_memfile_extend>
103fb9: 89 45 c8 mov %eax,-0x38(%ebp)
if ( status )
103fbc: 85 c0 test %eax,%eax
103fbe: 0f 84 ae fe ff ff je 103e72 <IMFS_memfile_write+0x22>
103fc4: eb bc jmp 103f82 <IMFS_memfile_write+0x132>
103fc6: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
103fcd: 8d 76 00 lea 0x0(%esi),%esi
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
103fd0: 89 45 cc mov %eax,-0x34(%ebp)
103fd3: 8b 45 08 mov 0x8(%ebp),%eax
103fd6: 31 c9 xor %ecx,%ecx
103fd8: e8 73 f6 ff ff call 103650 <IMFS_memfile_get_block_pointer>
if ( !block_ptr )
103fdd: 85 c0 test %eax,%eax
block_ptr = IMFS_memfile_get_block_pointer( memfile, block, 0 );
103fdf: 89 c6 mov %eax,%esi
if ( !block_ptr )
103fe1: 0f 84 d9 00 00 00 je 1040c0 <IMFS_memfile_write+0x270> <== NEVER TAKEN
103fe7: 8b 45 18 mov 0x18(%ebp),%eax
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
103fea: 89 d9 mov %ebx,%ecx
103fec: 29 f9 sub %edi,%ecx
103fee: 8b 55 cc mov -0x34(%ebp),%edx
103ff1: 39 c8 cmp %ecx,%eax
103ff3: 77 7b ja 104070 <IMFS_memfile_write+0x220>
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
103ff5: 89 45 cc mov %eax,-0x34(%ebp)
103ff8: 8b 0e mov (%esi),%ecx
103ffa: 8b 75 14 mov 0x14(%ebp),%esi
103ffd: 01 cf add %ecx,%edi
103fff: 83 f8 08 cmp $0x8,%eax
104002: 73 7d jae 104081 <IMFS_memfile_write+0x231>
104004: 8b 4d cc mov -0x34(%ebp),%ecx
104007: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
block++;
104009: 8d 72 01 lea 0x1(%edx),%esi
copied += to_copy;
10400c: 89 45 c8 mov %eax,-0x38(%ebp)
src += to_copy;
10400f: 01 45 14 add %eax,0x14(%ebp)
my_length -= to_copy;
104012: 29 45 18 sub %eax,0x18(%ebp)
copied += to_copy;
104015: e9 94 fe ff ff jmp 103eae <IMFS_memfile_write+0x5e>
10401a: 8d b6 00 00 00 00 lea 0x0(%esi),%esi
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
104020: 0f b7 06 movzwl (%esi),%eax <== NOT EXECUTED
104023: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
104026: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
104029: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
10402c: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED
104030: e9 d6 fe ff ff jmp 103f0b <IMFS_memfile_write+0xbb> <== NOT EXECUTED
104035: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10403c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
104040: 0f b6 0e movzbl (%esi),%ecx <== NOT EXECUTED
104043: 47 inc %edi <== NOT EXECUTED
104044: 88 4d cc mov %cl,-0x34(%ebp) <== NOT EXECUTED
104047: 88 08 mov %cl,(%eax) <== NOT EXECUTED
104049: 8d 4b ff lea -0x1(%ebx),%ecx <== NOT EXECUTED
10404c: 8b 45 14 mov 0x14(%ebp),%eax <== NOT EXECUTED
10404f: 8d 70 01 lea 0x1(%eax),%esi <== NOT EXECUTED
104052: e9 a8 fe ff ff jmp 103eff <IMFS_memfile_write+0xaf> <== NOT EXECUTED
104057: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
10405e: 66 90 xchg %ax,%ax <== NOT EXECUTED
bool zero_fill = start > memfile->File.size;
104060: c7 45 cc 00 00 00 00 movl $0x0,-0x34(%ebp)
104067: e9 39 ff ff ff jmp 103fa5 <IMFS_memfile_write+0x155>
10406c: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
104070: 89 c8 mov %ecx,%eax
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
104072: 8b 0e mov (%esi),%ecx
104074: 89 45 cc mov %eax,-0x34(%ebp)
104077: 8b 75 14 mov 0x14(%ebp),%esi
10407a: 01 cf add %ecx,%edi
10407c: 83 f8 08 cmp $0x8,%eax
10407f: 72 83 jb 104004 <IMFS_memfile_write+0x1b4> <== NEVER TAKEN
104081: f7 c7 01 00 00 00 test $0x1,%edi
104087: 0f 85 81 00 00 00 jne 10410e <IMFS_memfile_write+0x2be>
10408d: f7 c7 02 00 00 00 test $0x2,%edi
104093: 75 66 jne 1040fb <IMFS_memfile_write+0x2ab>
104095: f7 c7 04 00 00 00 test $0x4,%edi
10409b: 0f 84 63 ff ff ff je 104004 <IMFS_memfile_write+0x1b4>
1040a1: 8b 0e mov (%esi),%ecx
1040a3: 83 c7 04 add $0x4,%edi
1040a6: 83 c6 04 add $0x4,%esi
1040a9: 89 4f fc mov %ecx,-0x4(%edi)
1040ac: 83 6d cc 04 subl $0x4,-0x34(%ebp)
1040b0: e9 4f ff ff ff jmp 104004 <IMFS_memfile_write+0x1b4>
1040b5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1040bc: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
return copied;
1040c0: c7 45 c8 00 00 00 00 movl $0x0,-0x38(%ebp) <== NOT EXECUTED
1040c7: e9 b6 fe ff ff jmp 103f82 <IMFS_memfile_write+0x132> <== NOT EXECUTED
memcpy( &(*block_ptr)[ 0 ], src, my_length );
1040cc: f7 c7 01 00 00 00 test $0x1,%edi
1040d2: 75 62 jne 104136 <IMFS_memfile_write+0x2e6> <== NEVER TAKEN
1040d4: f7 c7 02 00 00 00 test $0x2,%edi
1040da: 75 48 jne 104124 <IMFS_memfile_write+0x2d4> <== NEVER TAKEN
1040dc: f7 c7 04 00 00 00 test $0x4,%edi
1040e2: 0f 84 72 fe ff ff je 103f5a <IMFS_memfile_write+0x10a>
1040e8: 8b 06 mov (%esi),%eax
1040ea: 83 c7 04 add $0x4,%edi
1040ed: 83 c6 04 add $0x4,%esi
1040f0: 83 e9 04 sub $0x4,%ecx
1040f3: 89 47 fc mov %eax,-0x4(%edi)
1040f6: e9 5f fe ff ff jmp 103f5a <IMFS_memfile_write+0x10a>
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
1040fb: 0f b7 0e movzwl (%esi),%ecx
1040fe: 83 c7 02 add $0x2,%edi
104101: 83 c6 02 add $0x2,%esi
104104: 66 89 4f fe mov %cx,-0x2(%edi)
104108: 83 6d cc 02 subl $0x2,-0x34(%ebp)
10410c: eb 87 jmp 104095 <IMFS_memfile_write+0x245>
10410e: 0f b6 0e movzbl (%esi),%ecx
104111: 47 inc %edi
104112: 88 4f ff mov %cl,-0x1(%edi)
104115: 8d 48 ff lea -0x1(%eax),%ecx
104118: 89 4d cc mov %ecx,-0x34(%ebp)
10411b: 8b 75 14 mov 0x14(%ebp),%esi
10411e: 46 inc %esi
10411f: e9 69 ff ff ff jmp 10408d <IMFS_memfile_write+0x23d>
memcpy( &(*block_ptr)[ 0 ], src, my_length );
104124: 0f b7 06 movzwl (%esi),%eax <== NOT EXECUTED
104127: 83 c7 02 add $0x2,%edi <== NOT EXECUTED
10412a: 83 c6 02 add $0x2,%esi <== NOT EXECUTED
10412d: 83 e9 02 sub $0x2,%ecx <== NOT EXECUTED
104130: 66 89 47 fe mov %ax,-0x2(%edi) <== NOT EXECUTED
104134: eb a6 jmp 1040dc <IMFS_memfile_write+0x28c> <== NOT EXECUTED
104136: 0f b6 06 movzbl (%esi),%eax <== NOT EXECUTED
104139: 47 inc %edi <== NOT EXECUTED
10413a: 46 inc %esi <== NOT EXECUTED
10413b: 88 47 ff mov %al,-0x1(%edi) <== NOT EXECUTED
10413e: 8b 45 18 mov 0x18(%ebp),%eax <== NOT EXECUTED
104141: 8d 48 ff lea -0x1(%eax),%ecx <== NOT EXECUTED
104144: eb 8e jmp 1040d4 <IMFS_memfile_write+0x284> <== NOT EXECUTED
104146: 90 nop
104147: 90 nop
104148: 90 nop
104149: 90 nop
10414a: 90 nop
10414b: 90 nop
10414c: 90 nop
10414d: 90 nop
10414e: 90 nop
10414f: 90 nop
001042b0 <IMFS_mount>:
#endif
#include <rtems/imfs.h>
int IMFS_mount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
1042b0: 55 push %ebp
1042b1: 89 e5 mov %esp,%ebp
1042b3: 83 ec 08 sub $0x8,%esp
1042b6: 8b 4d 08 mov 0x8(%ebp),%ecx
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
1042b9: 8b 41 20 mov 0x20(%ecx),%eax
1042bc: 8b 50 08 mov 0x8(%eax),%edx
return S_ISDIR( node->st_mode );
1042bf: 8b 42 14 mov 0x14(%edx),%eax
1042c2: 25 00 f0 00 00 and $0xf000,%eax
if ( IMFS_is_directory( node ) ) {
1042c7: 3d 00 40 00 00 cmp $0x4000,%eax
1042cc: 75 32 jne 104300 <IMFS_mount+0x50>
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == NULL ) {
1042ce: 8b 42 48 mov 0x48(%edx),%eax
1042d1: 85 c0 test %eax,%eax
1042d3: 75 0b jne 1042e0 <IMFS_mount+0x30> <== NEVER TAKEN
dir->mt_fs = mt_entry;
1042d5: 89 4a 48 mov %ecx,0x48(%edx)
int rv = 0;
1042d8: 31 c0 xor %eax,%eax
errno = ENOTDIR;
rv = -1;
}
return rv;
}
1042da: 89 ec mov %ebp,%esp
1042dc: 5d pop %ebp
1042dd: c3 ret
1042de: 66 90 xchg %ax,%ax
errno = EBUSY;
1042e0: e8 ab 4d 01 00 call 119090 <__errno> <== NOT EXECUTED
1042e5: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED
rv = -1;
1042eb: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
1042f0: eb e8 jmp 1042da <IMFS_mount+0x2a> <== NOT EXECUTED
1042f2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1042f9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
errno = ENOTDIR;
104300: e8 8b 4d 01 00 call 119090 <__errno>
104305: c7 00 14 00 00 00 movl $0x14,(%eax)
rv = -1;
10430b: b8 ff ff ff ff mov $0xffffffff,%eax
return rv;
104310: eb c8 jmp 1042da <IMFS_mount+0x2a>
104312: 90 nop
104313: 90 nop
104314: 90 nop
104315: 90 nop
104316: 90 nop
104317: 90 nop
104318: 90 nop
104319: 90 nop
10431a: 90 nop
10431b: 90 nop
10431c: 90 nop
10431d: 90 nop
10431e: 90 nop
10431f: 90 nop
0010a340 <IMFS_node_remove_directory>:
{
return dir->mt_fs != NULL;
}
IMFS_jnode_t *IMFS_node_remove_directory( IMFS_jnode_t *node )
{
10a340: 55 push %ebp
10a341: 89 e5 mov %esp,%ebp
10a343: 83 ec 08 sub $0x8,%esp
10a346: 8b 45 08 mov 0x8(%ebp),%eax
return &the_chain->Tail.Node;
10a349: 8d 50 40 lea 0x40(%eax),%edx
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( !rtems_chain_is_empty( &dir->Entries ) ) {
10a34c: 39 50 3c cmp %edx,0x3c(%eax)
10a34f: 74 1f je 10a370 <IMFS_node_remove_directory+0x30>
errno = ENOTEMPTY;
10a351: e8 3a ed 00 00 call 119090 <__errno>
10a356: c7 00 5a 00 00 00 movl $0x5a,(%eax)
dir = NULL;
10a35c: 31 c0 xor %eax,%eax
errno = EBUSY;
dir = NULL;
}
return &dir->Node;
}
10a35e: 89 ec mov %ebp,%esp
10a360: 5d pop %ebp
10a361: c3 ret
10a362: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10a369: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
} else if ( IMFS_is_mount_point( dir ) ) {
10a370: 8b 50 48 mov 0x48(%eax),%edx
10a373: 85 d2 test %edx,%edx
10a375: 74 e7 je 10a35e <IMFS_node_remove_directory+0x1e> <== ALWAYS TAKEN
errno = EBUSY;
10a377: e8 14 ed 00 00 call 119090 <__errno> <== NOT EXECUTED
10a37c: c7 00 10 00 00 00 movl $0x10,(%eax) <== NOT EXECUTED
}
10a382: 89 ec mov %ebp,%esp <== NOT EXECUTED
dir = NULL;
10a384: 31 c0 xor %eax,%eax <== NOT EXECUTED
}
10a386: 5d pop %ebp <== NOT EXECUTED
10a387: c3 ret <== NOT EXECUTED
10a388: 90 nop
10a389: 90 nop
10a38a: 90 nop
10a38b: 90 nop
10a38c: 90 nop
10a38d: 90 nop
10a38e: 90 nop
10a38f: 90 nop
00104800 <IMFS_readlink>:
{
104800: 55 push %ebp
104801: 89 e5 mov %esp,%ebp
104803: 56 push %esi
sym_link = loc->node_access;
104804: 8b 45 08 mov 0x8(%ebp),%eax
{
104807: 53 push %ebx
104808: 8b 4d 10 mov 0x10(%ebp),%ecx
10480b: 8b 75 0c mov 0xc(%ebp),%esi
sym_link = loc->node_access;
10480e: 8b 58 08 mov 0x8(%eax),%ebx
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
104811: 31 c0 xor %eax,%eax
104813: 85 c9 test %ecx,%ecx
104815: 75 11 jne 104828 <IMFS_readlink+0x28> <== ALWAYS TAKEN
104817: eb 1a jmp 104833 <IMFS_readlink+0x33> <== NOT EXECUTED
104819: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
buf[i] = sym_link->name[i];
104820: 88 14 06 mov %dl,(%esi,%eax,1)
for( i=0; ((i<bufsize) && (sym_link->name[i] != '\0')); i++ )
104823: 40 inc %eax
104824: 39 c8 cmp %ecx,%eax
104826: 74 0b je 104833 <IMFS_readlink+0x33>
104828: 8b 53 3c mov 0x3c(%ebx),%edx
10482b: 0f b6 14 02 movzbl (%edx,%eax,1),%edx
10482f: 84 d2 test %dl,%dl
104831: 75 ed jne 104820 <IMFS_readlink+0x20>
}
104833: 5b pop %ebx
104834: 5e pop %esi
104835: 5d pop %ebp
104836: c3 ret
104837: 90 nop
104838: 90 nop
104839: 90 nop
10483a: 90 nop
10483b: 90 nop
10483c: 90 nop
10483d: 90 nop
10483e: 90 nop
10483f: 90 nop
001044a0 <IMFS_rename>:
const rtems_filesystem_location_info_t *oldloc,
const rtems_filesystem_location_info_t *newparentloc,
const char *name,
size_t namelen
)
{
1044a0: 55 push %ebp
1044a1: 89 e5 mov %esp,%ebp
1044a3: 57 push %edi
1044a4: 56 push %esi
1044a5: 53 push %ebx
1044a6: 83 ec 3c sub $0x3c,%esp
/*
* FIXME: Due to insufficient checks we can create inaccessible nodes with
* this operation.
*/
node = oldloc->node_access;
1044a9: 8b 45 0c mov 0xc(%ebp),%eax
1044ac: 8b 58 08 mov 0x8(%eax),%ebx
new_parent = newparentloc->node_access;
1044af: 8b 45 10 mov 0x10(%ebp),%eax
1044b2: 8b 50 08 mov 0x8(%eax),%edx
if ( node->Parent == NULL ) {
1044b5: 8b 43 08 mov 0x8(%ebx),%eax
1044b8: 85 c0 test %eax,%eax
1044ba: 0f 84 35 01 00 00 je 1045f5 <IMFS_rename+0x155> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( namelen >= IMFS_NAME_MAX ) {
1044c0: 81 7d 18 fe 00 00 00 cmpl $0xfe,0x18(%ebp)
1044c7: 0f 87 13 01 00 00 ja 1045e0 <IMFS_rename+0x140>
1044cd: 89 55 d4 mov %edx,-0x2c(%ebp)
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
}
control = malloc( sizeof( *control ) + namelen );
1044d0: 8b 45 18 mov 0x18(%ebp),%eax
1044d3: 83 c0 14 add $0x14,%eax
1044d6: 89 04 24 mov %eax,(%esp)
1044d9: e8 02 cb ff ff call 100fe0 <malloc>
if ( control == NULL ) {
1044de: 8b 55 d4 mov -0x2c(%ebp),%edx
1044e1: 85 c0 test %eax,%eax
1044e3: 0f 84 21 01 00 00 je 10460a <IMFS_rename+0x16a> <== NEVER TAKEN
rtems_set_errno_and_return_minus_one( ENOMEM );
}
memcpy( control->name, name, namelen );
1044e9: 8b 4d 18 mov 0x18(%ebp),%ecx
1044ec: 8d 78 14 lea 0x14(%eax),%edi
1044ef: 89 7d d4 mov %edi,-0x2c(%ebp)
1044f2: 8b 75 14 mov 0x14(%ebp),%esi
1044f5: 83 f9 08 cmp $0x8,%ecx
1044f8: 0f 83 82 00 00 00 jae 104580 <IMFS_rename+0xe0> <== NEVER TAKEN
1044fe: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
if ( node->control->node_destroy == IMFS_renamed_destroy ) {
104500: 8b 4b 38 mov 0x38(%ebx),%ecx
104503: 81 79 0c 70 44 10 00 cmpl $0x104470,0xc(%ecx)
10450a: 0f 84 a0 00 00 00 je 1045b0 <IMFS_rename+0x110>
IMFS_restore_replaced_control( node );
}
control->Base = *node->control;
104510: 8b 31 mov (%ecx),%esi
104512: 89 30 mov %esi,(%eax)
104514: 8b 71 04 mov 0x4(%ecx),%esi
104517: 89 70 04 mov %esi,0x4(%eax)
10451a: 8b 71 08 mov 0x8(%ecx),%esi
control->Base.node_destroy = IMFS_renamed_destroy;
control->replaced = node->control;
10451d: 89 48 10 mov %ecx,0x10(%eax)
next = the_node->next;
104520: 8b 0b mov (%ebx),%ecx
control->Base.node_destroy = IMFS_renamed_destroy;
104522: c7 40 0c 70 44 10 00 movl $0x104470,0xc(%eax)
control->Base = *node->control;
104529: 89 70 08 mov %esi,0x8(%eax)
node->control = &control->Base;
10452c: 89 43 38 mov %eax,0x38(%ebx)
node->name = control->name;
10452f: 8b 45 d4 mov -0x2c(%ebp),%eax
104532: 89 43 0c mov %eax,0xc(%ebx)
node->namelen = namelen;
104535: 8b 45 18 mov 0x18(%ebp),%eax
104538: 66 89 43 10 mov %ax,0x10(%ebx)
previous = the_node->previous;
10453c: 8b 43 04 mov 0x4(%ebx),%eax
next->previous = previous;
10453f: 89 41 04 mov %eax,0x4(%ecx)
previous->next = next;
104542: 89 08 mov %ecx,(%eax)
old_last = tail->previous;
104544: 8b 42 44 mov 0x44(%edx),%eax
return &the_chain->Tail.Node;
104547: 8d 4a 40 lea 0x40(%edx),%ecx
entry_node->Parent = dir_node;
10454a: 89 53 08 mov %edx,0x8(%ebx)
10454d: 89 0b mov %ecx,(%ebx)
tail->previous = the_node;
10454f: 89 5a 44 mov %ebx,0x44(%edx)
old_last->next = the_node;
104552: 89 18 mov %ebx,(%eax)
the_node->previous = old_last;
104554: 89 43 04 mov %eax,0x4(%ebx)
_Timecounter_Getbintime( &now );
104557: 8d 45 d8 lea -0x28(%ebp),%eax
10455a: 89 04 24 mov %eax,(%esp)
10455d: e8 8e 1f 00 00 call 1064f0 <_Timecounter_Getbintime>
return now.sec;
104562: 8b 45 d8 mov -0x28(%ebp),%eax
104565: 8b 55 dc mov -0x24(%ebp),%edx
jnode->stat_ctime = _IMFS_get_time();
104568: 89 43 30 mov %eax,0x30(%ebx)
IMFS_remove_from_directory( node );
IMFS_add_to_directory( new_parent, node );
IMFS_update_ctime( node );
return 0;
10456b: 31 c0 xor %eax,%eax
10456d: 89 53 34 mov %edx,0x34(%ebx)
}
104570: 83 c4 3c add $0x3c,%esp
104573: 5b pop %ebx
104574: 5e pop %esi
104575: 5f pop %edi
104576: 5d pop %ebp
104577: c3 ret
104578: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
10457f: 90 nop
memcpy( control->name, name, namelen );
104580: f7 c7 04 00 00 00 test $0x4,%edi <== NOT EXECUTED
104586: 0f 84 72 ff ff ff je 1044fe <IMFS_rename+0x5e> <== NOT EXECUTED
10458c: 8b 0e mov (%esi),%ecx <== NOT EXECUTED
10458e: 8d 78 18 lea 0x18(%eax),%edi <== NOT EXECUTED
104591: 83 c6 04 add $0x4,%esi <== NOT EXECUTED
104594: 89 48 14 mov %ecx,0x14(%eax) <== NOT EXECUTED
104597: 8b 4d 18 mov 0x18(%ebp),%ecx <== NOT EXECUTED
10459a: 83 e9 04 sub $0x4,%ecx <== NOT EXECUTED
10459d: e9 5c ff ff ff jmp 1044fe <IMFS_rename+0x5e> <== NOT EXECUTED
1045a2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1045a9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
1045b0: 89 45 cc mov %eax,-0x34(%ebp)
node->control = control->replaced;
1045b3: 8b 71 10 mov 0x10(%ecx),%esi
1045b6: 89 55 d0 mov %edx,-0x30(%ebp)
1045b9: 89 73 38 mov %esi,0x38(%ebx)
free( control );
1045bc: 89 0c 24 mov %ecx,(%esp)
1045bf: e8 ec 51 00 00 call 1097b0 <free>
control->Base = *node->control;
1045c4: 8b 4b 38 mov 0x38(%ebx),%ecx
1045c7: 8b 45 cc mov -0x34(%ebp),%eax
1045ca: 8b 55 d0 mov -0x30(%ebp),%edx
}
1045cd: e9 3e ff ff ff jmp 104510 <IMFS_rename+0x70>
1045d2: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1045d9: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
1045e0: e8 ab 4a 01 00 call 119090 <__errno>
1045e5: c7 00 5b 00 00 00 movl $0x5b,(%eax)
1045eb: b8 ff ff ff ff mov $0xffffffff,%eax
1045f0: e9 7b ff ff ff jmp 104570 <IMFS_rename+0xd0>
rtems_set_errno_and_return_minus_one( EINVAL );
1045f5: e8 96 4a 01 00 call 119090 <__errno> <== NOT EXECUTED
1045fa: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
104600: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
104605: e9 66 ff ff ff jmp 104570 <IMFS_rename+0xd0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
10460a: e8 81 4a 01 00 call 119090 <__errno> <== NOT EXECUTED
10460f: c7 00 0c 00 00 00 movl $0xc,(%eax) <== NOT EXECUTED
104615: 83 c8 ff or $0xffffffff,%eax <== NOT EXECUTED
104618: e9 53 ff ff ff jmp 104570 <IMFS_rename+0xd0> <== NOT EXECUTED
10461d: 90 nop
10461e: 90 nop
10461f: 90 nop
00104840 <IMFS_unmount>:
#endif
#include <rtems/imfs.h>
int IMFS_unmount( rtems_filesystem_mount_table_entry_t *mt_entry )
{
104840: 55 push %ebp
104841: 89 e5 mov %esp,%ebp
104843: 83 ec 08 sub $0x8,%esp
104846: 8b 4d 08 mov 0x8(%ebp),%ecx
int rv = 0;
IMFS_jnode_t *node = mt_entry->mt_point_node->location.node_access;
104849: 8b 41 20 mov 0x20(%ecx),%eax
10484c: 8b 50 08 mov 0x8(%eax),%edx
return S_ISDIR( node->st_mode );
10484f: 8b 42 14 mov 0x14(%edx),%eax
104852: 25 00 f0 00 00 and $0xf000,%eax
if ( IMFS_is_directory( node ) ) {
104857: 3d 00 40 00 00 cmp $0x4000,%eax
10485c: 75 32 jne 104890 <IMFS_unmount+0x50> <== NEVER TAKEN
IMFS_directory_t *dir = (IMFS_directory_t *) node;
if ( dir->mt_fs == mt_entry ) {
10485e: 39 4a 48 cmp %ecx,0x48(%edx)
104861: 75 0d jne 104870 <IMFS_unmount+0x30> <== NEVER TAKEN
dir->mt_fs = NULL;
104863: c7 42 48 00 00 00 00 movl $0x0,0x48(%edx)
int rv = 0;
10486a: 31 c0 xor %eax,%eax
errno = ENOTDIR;
rv = -1;
}
return rv;
}
10486c: 89 ec mov %ebp,%esp
10486e: 5d pop %ebp
10486f: c3 ret
errno = EINVAL;
104870: e8 1b 48 01 00 call 119090 <__errno> <== NOT EXECUTED
104875: c7 00 16 00 00 00 movl $0x16,(%eax) <== NOT EXECUTED
rv = -1;
10487b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
104880: eb ea jmp 10486c <IMFS_unmount+0x2c> <== NOT EXECUTED
104882: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
104889: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
errno = ENOTDIR;
104890: e8 fb 47 01 00 call 119090 <__errno> <== NOT EXECUTED
104895: c7 00 14 00 00 00 movl $0x14,(%eax) <== NOT EXECUTED
rv = -1;
10489b: b8 ff ff ff ff mov $0xffffffff,%eax <== NOT EXECUTED
return rv;
1048a0: eb ca jmp 10486c <IMFS_unmount+0x2c> <== NOT EXECUTED
1048a2: 90 nop
1048a3: 90 nop
1048a4: 90 nop
1048a5: 90 nop
1048a6: 90 nop
1048a7: 90 nop
1048a8: 90 nop
1048a9: 90 nop
1048aa: 90 nop
1048ab: 90 nop
1048ac: 90 nop
1048ad: 90 nop
1048ae: 90 nop
1048af: 90 nop
0010a1e0 <device_ftruncate>:
rtems_libio_t *iop,
off_t length
)
{
return 0;
}
10a1e0: 31 c0 xor %eax,%eax <== NOT EXECUTED
10a1e2: c3 ret <== NOT EXECUTED
10a1e3: 90 nop
10a1e4: 90 nop
10a1e5: 90 nop
10a1e6: 90 nop
10a1e7: 90 nop
10a1e8: 90 nop
10a1e9: 90 nop
10a1ea: 90 nop
10a1eb: 90 nop
10a1ec: 90 nop
10a1ed: 90 nop
10a1ee: 90 nop
10a1ef: 90 nop
00105500 <rtems_tarfs_load>:
int rtems_tarfs_load(
const char *mountpoint,
uint8_t *tar_image,
size_t tar_size
)
{
105500: 55 push %ebp <== NOT EXECUTED
105501: 89 e5 mov %esp,%ebp <== NOT EXECUTED
105503: 57 push %edi <== NOT EXECUTED
105504: 56 push %esi <== NOT EXECUTED
105505: 53 push %ebx <== NOT EXECUTED
105506: 81 ec ec 01 00 00 sub $0x1ec,%esp <== NOT EXECUTED
10550c: 8b 75 08 mov 0x8(%ebp),%esi <== NOT EXECUTED
10550f: 8b 5d 0c mov 0xc(%ebp),%ebx <== NOT EXECUTED
char buf[ 156 + UNTAR_FILE_NAME_SIZE ];
size_t len;
Untar_HeaderContext ctx;
unsigned long ptr;
len = strlen( mountpoint );
105512: 89 34 24 mov %esi,(%esp) <== NOT EXECUTED
105515: e8 26 78 02 00 call 12cd40 <strlen> <== NOT EXECUTED
if ( len >= sizeof( buf ) - UNTAR_FILE_NAME_SIZE - 2 ) {
10551a: 3d 99 00 00 00 cmp $0x99,%eax
10551f: 0f 87 cb 00 00 00 ja 1055f0 <rtems_tarfs_load+0xf0> <== NEVER TAKEN
return -1;
}
eval_flags = RTEMS_FS_FOLLOW_LINK;
loc = rtems_filesystem_eval_path_start( &eval_ctx, mountpoint, eval_flags );
105525: 89 74 24 04 mov %esi,0x4(%esp)
105529: 8d bd 30 fe ff ff lea -0x1d0(%ebp),%edi
10552f: ba 18 00 00 00 mov $0x18,%edx
105534: 89 54 24 08 mov %edx,0x8(%esp)
105538: 89 3c 24 mov %edi,(%esp)
10553b: 89 85 20 fe ff ff mov %eax,-0x1e0(%ebp)
105541: e8 4a d6 ff ff call 102b90 <rtems_filesystem_eval_path_start>
return loc->mt_entry->ops->clonenod_h == IMFS_node_clone;
105546: 8b 40 14 mov 0x14(%eax),%eax
105549: 8b 40 0c mov 0xc(%eax),%eax
10554c: 8b 40 24 mov 0x24(%eax),%eax
is_imfs = IMFS_is_imfs_instance( loc );
rtems_filesystem_eval_path_cleanup( &eval_ctx );
10554f: 89 3c 24 mov %edi,(%esp)
105552: 89 85 24 fe ff ff mov %eax,-0x1dc(%ebp)
105558: e8 e3 d7 ff ff call 102d40 <rtems_filesystem_eval_path_cleanup>
if ( !is_imfs ) {
10555d: 81 bd 24 fe ff ff f0 cmpl $0x1066f0,-0x1dc(%ebp)
105564: 66 10 00
105567: 0f 85 83 00 00 00 jne 1055f0 <rtems_tarfs_load+0xf0>
return -1;
}
ctx.printer = NULL;
ctx.file_path = memcpy( buf, mountpoint, len );
10556d: 8b 95 20 fe ff ff mov -0x1e0(%ebp),%edx
ctx.printer = NULL;
105573: 31 c0 xor %eax,%eax
105575: 89 85 e4 fe ff ff mov %eax,-0x11c(%ebp)
ctx.file_path = memcpy( buf, mountpoint, len );
10557b: 8d 85 e8 fe ff ff lea -0x118(%ebp),%eax
105581: 89 c7 mov %eax,%edi
105583: 83 fa 08 cmp $0x8,%edx
105586: 89 d1 mov %edx,%ecx
105588: 0f 83 d2 00 00 00 jae 105660 <rtems_tarfs_load+0x160> <== NEVER TAKEN
10558e: f3 a4 rep movsb %ds:(%esi),%es:(%edi)
if ( len > 0 && ctx.file_path[ len - 1 ] != '/') {
105590: 85 d2 test %edx,%edx
ctx.file_path = memcpy( buf, mountpoint, len );
105592: 89 c1 mov %eax,%ecx
105594: 89 85 68 fe ff ff mov %eax,-0x198(%ebp)
if ( len > 0 && ctx.file_path[ len - 1 ] != '/') {
10559a: 75 64 jne 105600 <rtems_tarfs_load+0x100> <== ALWAYS TAKEN
ctx.file_path[ len ] = '/';
ctx.file_name = ctx.file_path + len + 1;
} else {
ctx.file_name = ctx.file_path + len;
10559c: 89 8d 6c fe ff ff mov %ecx,-0x194(%ebp)
ptr = 0;
while ( ptr + 512 <= tar_size ) {
int retval;
retval = Untar_ProcessHeader( &ctx, (const char *) &tar_image[ ptr ] );
1055a2: 8d bd 68 fe ff ff lea -0x198(%ebp),%edi
1055a8: 31 f6 xor %esi,%esi
1055aa: eb 1f jmp 1055cb <rtems_tarfs_load+0xcb>
1055ac: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1055b0: 89 3c 24 mov %edi,(%esp)
1055b3: 01 d8 add %ebx,%eax
1055b5: 89 44 24 04 mov %eax,0x4(%esp)
1055b9: e8 d2 1a 00 00 call 107090 <Untar_ProcessHeader>
if ( retval != UNTAR_SUCCESSFUL ) {
1055be: 85 c0 test %eax,%eax
1055c0: 75 2e jne 1055f0 <rtems_tarfs_load+0xf0> <== NEVER TAKEN
return -1;
}
ptr += 512;
if ( ctx.linkflag == REGTYPE ) {
1055c2: 80 bd e0 fe ff ff 30 cmpb $0x30,-0x120(%ebp)
1055c9: 74 55 je 105620 <rtems_tarfs_load+0x120>
while ( ptr + 512 <= tar_size ) {
1055cb: 89 f0 mov %esi,%eax
1055cd: 81 c6 00 02 00 00 add $0x200,%esi
1055d3: 3b 75 10 cmp 0x10(%ebp),%esi
1055d6: 76 d8 jbe 1055b0 <rtems_tarfs_load+0xb0>
ptr += 512 * ctx.nblocks;
}
}
return 0;
}
1055d8: 81 c4 ec 01 00 00 add $0x1ec,%esp
return 0;
1055de: 31 c0 xor %eax,%eax
}
1055e0: 5b pop %ebx
1055e1: 5e pop %esi
1055e2: 5f pop %edi
1055e3: 5d pop %ebp
1055e4: c3 ret
1055e5: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi
1055ec: 8d 74 26 00 lea 0x0(%esi,%eiz,1),%esi
1055f0: 81 c4 ec 01 00 00 add $0x1ec,%esp
return -1;
1055f6: b8 ff ff ff ff mov $0xffffffff,%eax
}
1055fb: 5b pop %ebx
1055fc: 5e pop %esi
1055fd: 5f pop %edi
1055fe: 5d pop %ebp
1055ff: c3 ret
if ( len > 0 && ctx.file_path[ len - 1 ] != '/') {
105600: 80 7c 10 ff 2f cmpb $0x2f,-0x1(%eax,%edx,1)
ctx.file_path[ len ] = '/';
105605: 8d 0c 10 lea (%eax,%edx,1),%ecx
if ( len > 0 && ctx.file_path[ len - 1 ] != '/') {
105608: 74 92 je 10559c <rtems_tarfs_load+0x9c> <== ALWAYS TAKEN
ctx.file_path[ len ] = '/';
10560a: c6 01 2f movb $0x2f,(%ecx) <== NOT EXECUTED
ctx.file_name = ctx.file_path + len + 1;
10560d: 8d 44 10 01 lea 0x1(%eax,%edx,1),%eax <== NOT EXECUTED
105611: 89 85 6c fe ff ff mov %eax,-0x194(%ebp) <== NOT EXECUTED
105617: eb 89 jmp 1055a2 <rtems_tarfs_load+0xa2> <== NOT EXECUTED
105619: 8d b4 26 00 00 00 00 lea 0x0(%esi,%eiz,1),%esi <== NOT EXECUTED
retval = IMFS_make_linearfile(
105620: 8b 85 d8 fe ff ff mov -0x128(%ebp),%eax
105626: 89 44 24 0c mov %eax,0xc(%esp)
&tar_image[ ptr ],
10562a: 8d 04 33 lea (%ebx,%esi,1),%eax
retval = IMFS_make_linearfile(
10562d: 89 44 24 08 mov %eax,0x8(%esp)
105631: 8b 85 d4 fe ff ff mov -0x12c(%ebp),%eax
105637: 89 44 24 04 mov %eax,0x4(%esp)
10563b: 8b 85 68 fe ff ff mov -0x198(%ebp),%eax
105641: 89 04 24 mov %eax,(%esp)
105644: e8 47 01 00 00 call 105790 <IMFS_make_linearfile>
if ( retval != 0 ) {
105649: 85 c0 test %eax,%eax
10564b: 75 a3 jne 1055f0 <rtems_tarfs_load+0xf0> <== NEVER TAKEN
ptr += 512 * ctx.nblocks;
10564d: 8b 85 dc fe ff ff mov -0x124(%ebp),%eax
105653: c1 e0 09 shl $0x9,%eax
105656: 01 c6 add %eax,%esi
105658: e9 6e ff ff ff jmp 1055cb <rtems_tarfs_load+0xcb>
10565d: 8d 76 00 lea 0x0(%esi),%esi
ctx.file_path = memcpy( buf, mountpoint, len );
105660: a8 04 test $0x4,%al <== NOT EXECUTED
105662: 0f 84 26 ff ff ff je 10558e <rtems_tarfs_load+0x8e> <== NOT EXECUTED
105668: 8b 0e mov (%esi),%ecx <== NOT EXECUTED
10566a: 8d bd ec fe ff ff lea -0x114(%ebp),%edi <== NOT EXECUTED
105670: 83 c6 04 add $0x4,%esi <== NOT EXECUTED
105673: 89 08 mov %ecx,(%eax) <== NOT EXECUTED
105675: 8d 4a fc lea -0x4(%edx),%ecx <== NOT EXECUTED
105678: e9 11 ff ff ff jmp 10558e <rtems_tarfs_load+0x8e> <== NOT EXECUTED
10567d: 90 nop
10567e: 90 nop
10567f: 90 nop