00009c28 <IMFS_Set_handlers>:
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
switch( node->type ) {
9c28: e5903000 ldr r3, [r0]
9c2c: e593304c ldr r3, [r3, #76] ; 0x4c
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
9c30: e5902010 ldr r2, [r0, #16]
switch( node->type ) {
9c34: e2433001 sub r3, r3, #1
)
{
IMFS_jnode_t *node = loc->node_access;
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
9c38: e5922034 ldr r2, [r2, #52] ; 0x34
switch( node->type ) {
9c3c: e3530006 cmp r3, #6
9c40: 979ff103 ldrls pc, [pc, r3, lsl #2]
9c44: ea000008 b 9c6c <IMFS_Set_handlers+0x44> <== NOT EXECUTED
9c48: 00009c94 .word 0x00009c94 <== NOT EXECUTED
9c4c: 00009ca4 .word 0x00009ca4 <== NOT EXECUTED
9c50: 00009c84 .word 0x00009c84 <== NOT EXECUTED
9c54: 00009c84 .word 0x00009c84 <== NOT EXECUTED
9c58: 00009c74 .word 0x00009c74 <== NOT EXECUTED
9c5c: 00009c74 .word 0x00009c74 <== NOT EXECUTED
9c60: 00009c64 .word 0x00009c64 <== NOT EXECUTED
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_FIFO:
loc->handlers = &IMFS_fifo_handlers;
9c64: e59f3048 ldr r3, [pc, #72] ; 9cb4 <IMFS_Set_handlers+0x8c>
9c68: e5803008 str r3, [r0, #8]
break;
}
return 0;
}
9c6c: e3a00000 mov r0, #0
9c70: e12fff1e bx lr
break;
case IMFS_LINEAR_FILE:
loc->handlers = fs_info->memfile_handlers;
break;
case IMFS_MEMORY_FILE:
loc->handlers = fs_info->memfile_handlers;
9c74: e5923008 ldr r3, [r2, #8]
9c78: e5803008 str r3, [r0, #8]
loc->handlers = &IMFS_fifo_handlers;
break;
}
return 0;
}
9c7c: e3a00000 mov r0, #0
9c80: e12fff1e bx lr
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
break;
case IMFS_SYM_LINK:
case IMFS_HARD_LINK:
loc->handlers = &IMFS_link_handlers;
9c84: e59f302c ldr r3, [pc, #44] ; 9cb8 <IMFS_Set_handlers+0x90>
9c88: e5803008 str r3, [r0, #8]
loc->handlers = &IMFS_fifo_handlers;
break;
}
return 0;
}
9c8c: e3a00000 mov r0, #0
9c90: e12fff1e bx lr
IMFS_fs_info_t *fs_info;
fs_info = loc->mt_entry->fs_info;
switch( node->type ) {
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
9c94: e592300c ldr r3, [r2, #12]
9c98: e5803008 str r3, [r0, #8]
loc->handlers = &IMFS_fifo_handlers;
break;
}
return 0;
}
9c9c: e3a00000 mov r0, #0
9ca0: e12fff1e bx lr
switch( node->type ) {
case IMFS_DIRECTORY:
loc->handlers = fs_info->directory_handlers;
break;
case IMFS_DEVICE:
loc->handlers = &IMFS_device_handlers;
9ca4: e59f3010 ldr r3, [pc, #16] ; 9cbc <IMFS_Set_handlers+0x94>
9ca8: e5803008 str r3, [r0, #8]
loc->handlers = &IMFS_fifo_handlers;
break;
}
return 0;
}
9cac: e3a00000 mov r0, #0
9cb0: e12fff1e bx lr
00009ae0 <IMFS_create_node>:
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
9ae0: e92d40f0 push {r4, r5, r6, r7, lr}
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
9ae4: e2504000 subs r4, r0, #0
IMFS_jnode_types_t type,
const char *name,
mode_t mode,
const IMFS_types_union *info
)
{
9ae8: e1a05001 mov r5, r1
9aec: e59d6014 ldr r6, [sp, #20]
9af0: e1a01002 mov r1, r2
IMFS_fs_info_t *fs_info;
/*
* MUST have a parent node to call this routine.
*/
if ( parent_loc == NULL )
9af4: 01a07004 moveq r7, r4
9af8: 1a000001 bne 9b04 <IMFS_create_node+0x24>
node->st_ino = ++fs_info->ino_count;
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
9afc: e1a00007 mov r0, r7 <== NOT EXECUTED
9b00: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
return NULL;
/*
* Allocate filesystem node and fill in basic information
*/
node = IMFS_allocate_node( type, name, mode & ~rtems_filesystem_umask );
9b04: e59f210c ldr r2, [pc, #268] ; 9c18 <IMFS_create_node+0x138>
9b08: e5922000 ldr r2, [r2]
9b0c: e592202c ldr r2, [r2, #44] ; 0x2c
9b10: e1a00005 mov r0, r5
9b14: e1c32002 bic r2, r3, r2
9b18: ebffffc1 bl 9a24 <IMFS_allocate_node>
if ( !node )
9b1c: e2507000 subs r7, r0, #0
9b20: 0afffff5 beq 9afc <IMFS_create_node+0x1c>
return NULL;
/*
* Set the type specific information
*/
switch (type) {
9b24: e2455001 sub r5, r5, #1
9b28: e3550006 cmp r5, #6
9b2c: 979ff105 ldrls pc, [pc, r5, lsl #2]
9b30: ea000033 b 9c04 <IMFS_create_node+0x124> <== NOT EXECUTED
9b34: 00009be8 .word 0x00009be8 <== NOT EXECUTED
9b38: 00009bd4 .word 0x00009bd4 <== NOT EXECUTED
9b3c: 00009b50 .word 0x00009b50 <== NOT EXECUTED
9b40: 00009b50 .word 0x00009b50 <== NOT EXECUTED
9b44: 00009ba4 .word 0x00009ba4 <== NOT EXECUTED
9b48: 00009b8c .word 0x00009b8c <== NOT EXECUTED
9b4c: 00009bc8 .word 0x00009bc8 <== NOT EXECUTED
case IMFS_HARD_LINK:
node->info.hard_link.link_node = info->hard_link.link_node;
break;
case IMFS_SYM_LINK:
node->info.sym_link.name = info->sym_link.name;
9b50: e5963000 ldr r3, [r6]
9b54: e5873050 str r3, [r7, #80] ; 0x50
/*
* This node MUST have a parent, so put it in that directory list.
*/
parent = parent_loc->node_access;
fs_info = parent_loc->mt_entry->fs_info;
9b58: e5943010 ldr r3, [r4, #16]
9b5c: e5932034 ldr r2, [r3, #52] ; 0x34
node->Parent = parent;
node->st_ino = ++fs_info->ino_count;
9b60: e5923004 ldr r3, [r2, #4]
}
/*
* This node MUST have a parent, so put it in that directory list.
*/
parent = parent_loc->node_access;
9b64: e5940000 ldr r0, [r4]
fs_info = parent_loc->mt_entry->fs_info;
node->Parent = parent;
node->st_ino = ++fs_info->ino_count;
9b68: e2833001 add r3, r3, #1
9b6c: e5823004 str r3, [r2, #4]
* This node MUST have a parent, so put it in that directory list.
*/
parent = parent_loc->node_access;
fs_info = parent_loc->mt_entry->fs_info;
node->Parent = parent;
9b70: e5870008 str r0, [r7, #8]
node->st_ino = ++fs_info->ino_count;
9b74: e5873038 str r3, [r7, #56] ; 0x38
9b78: e2800050 add r0, r0, #80 ; 0x50
9b7c: e1a01007 mov r1, r7
9b80: ebfff14d bl 60bc <_Chain_Append>
rtems_chain_append( &parent->info.directory.Entries, &node->Node );
return node;
}
9b84: e1a00007 mov r0, r7
9b88: e8bd80f0 pop {r4, r5, r6, r7, pc}
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
break;
case IMFS_LINEAR_FILE:
node->info.linearfile.size = 0;
9b8c: e3a03000 mov r3, #0 <== NOT EXECUTED
9b90: e3a02000 mov r2, #0 <== NOT EXECUTED
9b94: e5872050 str r2, [r7, #80] ; 0x50 <== NOT EXECUTED
9b98: e5873054 str r3, [r7, #84] ; 0x54 <== NOT EXECUTED
node->info.linearfile.direct = 0;
9b9c: e3a03000 mov r3, #0 <== NOT EXECUTED
9ba0: e5873058 str r3, [r7, #88] ; 0x58 <== NOT EXECUTED
case IMFS_MEMORY_FILE:
node->info.file.size = 0;
node->info.file.indirect = 0;
9ba4: e3a03000 mov r3, #0
case IMFS_LINEAR_FILE:
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
case IMFS_MEMORY_FILE:
node->info.file.size = 0;
9ba8: e3a01000 mov r1, #0
9bac: e3a02000 mov r2, #0
9bb0: e5871050 str r1, [r7, #80] ; 0x50
9bb4: e5872054 str r2, [r7, #84] ; 0x54
node->info.file.indirect = 0;
node->info.file.doubly_indirect = 0;
node->info.file.triply_indirect = 0;
9bb8: e5873060 str r3, [r7, #96] ; 0x60
node->info.linearfile.size = 0;
node->info.linearfile.direct = 0;
case IMFS_MEMORY_FILE:
node->info.file.size = 0;
node->info.file.indirect = 0;
9bbc: e5873058 str r3, [r7, #88] ; 0x58
node->info.file.doubly_indirect = 0;
9bc0: e587305c str r3, [r7, #92] ; 0x5c
node->info.file.triply_indirect = 0;
break;
9bc4: eaffffe3 b 9b58 <IMFS_create_node+0x78>
case IMFS_FIFO:
node->info.fifo.pipe = NULL;
9bc8: e3a03000 mov r3, #0
9bcc: e5873050 str r3, [r7, #80] ; 0x50
break;
9bd0: eaffffe0 b 9b58 <IMFS_create_node+0x78>
node->info.sym_link.name = info->sym_link.name;
break;
case IMFS_DEVICE:
node->info.device.major = info->device.major;
node->info.device.minor = info->device.minor;
9bd4: e5962004 ldr r2, [r6, #4]
case IMFS_SYM_LINK:
node->info.sym_link.name = info->sym_link.name;
break;
case IMFS_DEVICE:
node->info.device.major = info->device.major;
9bd8: e5963000 ldr r3, [r6]
node->info.device.minor = info->device.minor;
9bdc: e5872054 str r2, [r7, #84] ; 0x54
case IMFS_SYM_LINK:
node->info.sym_link.name = info->sym_link.name;
break;
case IMFS_DEVICE:
node->info.device.major = info->device.major;
9be0: e5873050 str r3, [r7, #80] ; 0x50
node->info.device.minor = info->device.minor;
break;
9be4: eaffffdb b 9b58 <IMFS_create_node+0x78>
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
9be8: e2872054 add r2, r7, #84 ; 0x54
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
9bec: e2873050 add r3, r7, #80 ; 0x50
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
9bf0: e5872050 str r2, [r7, #80] ; 0x50
the_chain->permanent_null = NULL;
9bf4: e3a02000 mov r2, #0
9bf8: e5872054 str r2, [r7, #84] ; 0x54
the_chain->last = _Chain_Head(the_chain);
9bfc: e5873058 str r3, [r7, #88] ; 0x58
9c00: eaffffd4 b 9b58 <IMFS_create_node+0x78>
case IMFS_FIFO:
node->info.fifo.pipe = NULL;
break;
default:
assert(0);
9c04: e59f0010 ldr r0, [pc, #16] ; 9c1c <IMFS_create_node+0x13c> <== NOT EXECUTED
9c08: e3a0105c mov r1, #92 ; 0x5c <== NOT EXECUTED
9c0c: e59f200c ldr r2, [pc, #12] ; 9c20 <IMFS_create_node+0x140> <== NOT EXECUTED
9c10: e59f300c ldr r3, [pc, #12] ; 9c24 <IMFS_create_node+0x144> <== NOT EXECUTED
9c14: eb0003ce bl ab54 <__assert_func> <== NOT EXECUTED
00003f28 <IMFS_dump_directory>:
rtems_chain_node *the_node;
rtems_chain_control *the_chain;
IMFS_jnode_t *the_jnode;
int i;
assert( the_directory );
3f28: e3500000 cmp r0, #0
void IMFS_dump_directory(
IMFS_jnode_t *the_directory,
int level
)
{
3f2c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
3f30: e1a05001 mov r5, r1
rtems_chain_node *the_node;
rtems_chain_control *the_chain;
IMFS_jnode_t *the_jnode;
int i;
assert( the_directory );
3f34: 0a000021 beq 3fc0 <IMFS_dump_directory+0x98>
assert( level >= 0 );
3f38: e3510000 cmp r1, #0
3f3c: ba000029 blt 3fe8 <IMFS_dump_directory+0xc0>
assert( the_directory->type == IMFS_DIRECTORY );
3f40: e590304c ldr r3, [r0, #76] ; 0x4c
3f44: e3530001 cmp r3, #1
3f48: 1a000021 bne 3fd4 <IMFS_dump_directory+0xac>
the_chain = &the_directory->info.directory.Entries;
for ( the_node = the_chain->first;
3f4c: e5907050 ldr r7, [r0, #80] ; 0x50
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
3f50: e2808054 add r8, r0, #84 ; 0x54
3f54: e1570008 cmp r7, r8
3f58: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
3f5c: e59f6098 ldr r6, [pc, #152] ; 3ffc <IMFS_dump_directory+0xd4>
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( the_jnode->type == IMFS_DIRECTORY )
IMFS_dump_directory( the_jnode, level + 1 );
3f60: e281a001 add sl, r1, #1
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
3f64: e3a04000 mov r4, #0
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
3f68: e5963000 ldr r3, [r6]
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
3f6c: e2844001 add r4, r4, #1
fprintf(stdout, "...." );
3f70: e5933008 ldr r3, [r3, #8]
3f74: e59f0084 ldr r0, [pc, #132] ; 4000 <IMFS_dump_directory+0xd8>
3f78: e3a01001 mov r1, #1
3f7c: e3a02004 mov r2, #4
3f80: eb003dda bl 136f0 <fwrite>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
for ( i=0 ; i<=level ; i++ )
3f84: e1550004 cmp r5, r4
3f88: aafffff6 bge 3f68 <IMFS_dump_directory+0x40>
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
3f8c: e1a00007 mov r0, r7
3f90: ebffff7a bl 3d80 <IMFS_print_jnode>
if ( the_jnode->type == IMFS_DIRECTORY )
3f94: e597304c ldr r3, [r7, #76] ; 0x4c
3f98: e3530001 cmp r3, #1
3f9c: 0a000003 beq 3fb0 <IMFS_dump_directory+0x88>
the_chain = &the_directory->info.directory.Entries;
for ( the_node = the_chain->first;
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
3fa0: e5977000 ldr r7, [r7]
assert( the_directory->type == IMFS_DIRECTORY );
the_chain = &the_directory->info.directory.Entries;
for ( the_node = the_chain->first;
3fa4: e1570008 cmp r7, r8
3fa8: 1affffed bne 3f64 <IMFS_dump_directory+0x3c>
3fac: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
for ( i=0 ; i<=level ; i++ )
fprintf(stdout, "...." );
IMFS_print_jnode( the_jnode );
if ( the_jnode->type == IMFS_DIRECTORY )
IMFS_dump_directory( the_jnode, level + 1 );
3fb0: e1a00007 mov r0, r7
3fb4: e1a0100a mov r1, sl
3fb8: ebffffda bl 3f28 <IMFS_dump_directory>
3fbc: eafffff7 b 3fa0 <IMFS_dump_directory+0x78>
rtems_chain_node *the_node;
rtems_chain_control *the_chain;
IMFS_jnode_t *the_jnode;
int i;
assert( the_directory );
3fc0: e59f003c ldr r0, [pc, #60] ; 4004 <IMFS_dump_directory+0xdc><== NOT EXECUTED
3fc4: e3a01084 mov r1, #132 ; 0x84 <== NOT EXECUTED
3fc8: e59f2038 ldr r2, [pc, #56] ; 4008 <IMFS_dump_directory+0xe0><== NOT EXECUTED
3fcc: e59f3038 ldr r3, [pc, #56] ; 400c <IMFS_dump_directory+0xe4><== NOT EXECUTED
3fd0: eb000225 bl 486c <__assert_func> <== NOT EXECUTED
assert( level >= 0 );
assert( the_directory->type == IMFS_DIRECTORY );
3fd4: e59f0028 ldr r0, [pc, #40] ; 4004 <IMFS_dump_directory+0xdc><== NOT EXECUTED
3fd8: e3a01088 mov r1, #136 ; 0x88 <== NOT EXECUTED
3fdc: e59f2024 ldr r2, [pc, #36] ; 4008 <IMFS_dump_directory+0xe0><== NOT EXECUTED
3fe0: e59f3028 ldr r3, [pc, #40] ; 4010 <IMFS_dump_directory+0xe8><== NOT EXECUTED
3fe4: eb000220 bl 486c <__assert_func> <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
int i;
assert( the_directory );
assert( level >= 0 );
3fe8: e59f0014 ldr r0, [pc, #20] ; 4004 <IMFS_dump_directory+0xdc><== NOT EXECUTED
3fec: e3a01086 mov r1, #134 ; 0x86 <== NOT EXECUTED
3ff0: e59f2010 ldr r2, [pc, #16] ; 4008 <IMFS_dump_directory+0xe0><== NOT EXECUTED
3ff4: e59f3018 ldr r3, [pc, #24] ; 4014 <IMFS_dump_directory+0xec><== NOT EXECUTED
3ff8: eb00021b bl 486c <__assert_func> <== NOT EXECUTED
00009e20 <IMFS_eval_path>:
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
9e20: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
IMFS_token_types type = IMFS_CURRENT_DIR;
char token[ IMFS_NAME_MAX + 1 ];
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
9e24: e3d25007 bics r5, r2, #7
const char *pathname, /* IN */
size_t pathnamelen, /* IN */
int flags, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
9e28: e24dd02c sub sp, sp, #44 ; 0x2c
9e2c: e58d2000 str r2, [sp]
9e30: e1a0a000 mov sl, r0
9e34: e1a04001 mov r4, r1
9e38: e1a07003 mov r7, r3
IMFS_token_types type = IMFS_CURRENT_DIR;
char token[ IMFS_NAME_MAX + 1 ];
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
9e3c: 1a0000b8 bne a124 <IMFS_eval_path+0x304>
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
9e40: e5936000 ldr r6, [r3]
9e44: e28d8004 add r8, sp, #4
9e48: e28d9028 add r9, sp, #40 ; 0x28
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
9e4c: e1a02008 mov r2, r8
9e50: e1a03009 mov r3, r9
9e54: e08a0005 add r0, sl, r5
9e58: e1a01004 mov r1, r4
9e5c: eb00029d bl a8d8 <IMFS_get_token>
pathnamelen -= len;
i += len;
if ( !pathloc->node_access )
9e60: e5973000 ldr r3, [r7]
9e64: e3530000 cmp r3, #0
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
9e68: e1a0b000 mov fp, r0
pathnamelen -= len;
9e6c: e59d2028 ldr r2, [sp, #40] ; 0x28
i += len;
if ( !pathloc->node_access )
9e70: 0a000078 beq a058 <IMFS_eval_path+0x238>
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
9e74: e3500000 cmp r0, #0
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
i += len;
9e78: e0855002 add r5, r5, r2
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
type = IMFS_get_token( &pathname[i], pathnamelen, token, &len );
pathnamelen -= len;
9e7c: e0624004 rsb r4, r2, r4
rtems_set_errno_and_return_minus_one( ENOENT );
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
9e80: 1a00000f bne 9ec4 <IMFS_eval_path+0xa4>
* new fs root node and let let the mounted filesystem set the handlers.
*
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
9e84: e593204c ldr r2, [r3, #76] ; 0x4c
9e88: e3520001 cmp r2, #1
9e8c: 0a000076 beq a06c <IMFS_eval_path+0x24c>
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
9e90: e1a00007 mov r0, r7
9e94: ebffff63 bl 9c28 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
9e98: e59d1000 ldr r1, [sp]
flags, pathloc );
} else {
result = IMFS_Set_handlers( pathloc );
}
} else {
result = IMFS_Set_handlers( pathloc );
9e9c: e1a0b000 mov fp, r0
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( pathloc, flags ) )
9ea0: e1a00007 mov r0, r7
9ea4: ebffff85 bl 9cc0 <IMFS_evaluate_permission>
9ea8: e3500000 cmp r0, #0
9eac: 1a000036 bne 9f8c <IMFS_eval_path+0x16c>
rtems_set_errno_and_return_minus_one( EACCES );
9eb0: eb001102 bl e2c0 <__errno>
9eb4: e3a0300d mov r3, #13
9eb8: e5803000 str r3, [r0]
9ebc: e3e0b000 mvn fp, #0
9ec0: ea000031 b 9f8c <IMFS_eval_path+0x16c>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
9ec4: e596104c ldr r1, [r6, #76] ; 0x4c
9ec8: e3510001 cmp r1, #1
9ecc: 0a000053 beq a020 <IMFS_eval_path+0x200>
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
switch( type ) {
9ed0: e35b0003 cmp fp, #3
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
9ed4: e1a06003 mov r6, r3
switch( type ) {
9ed8: 0a000006 beq 9ef8 <IMFS_eval_path+0xd8>
9edc: e35b0004 cmp fp, #4
9ee0: 0a000025 beq 9f7c <IMFS_eval_path+0x15c>
9ee4: e35b0002 cmp fp, #2
9ee8: 0a000013 beq 9f3c <IMFS_eval_path+0x11c>
/*
* Evaluate all tokens until we are done or an error occurs.
*/
while( (type != IMFS_NO_MORE_PATH) && (type != IMFS_INVALID_TOKEN) ) {
9eec: e35b0004 cmp fp, #4
9ef0: 1affffd5 bne 9e4c <IMFS_eval_path+0x2c>
9ef4: eaffffe2 b 9e84 <IMFS_eval_path+0x64> <== NOT EXECUTED
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
9ef8: e593304c ldr r3, [r3, #76] ; 0x4c
9efc: e3530003 cmp r3, #3
9f00: 0a00004c beq a038 <IMFS_eval_path+0x218>
node = pathloc->node_access;
if ( !node )
rtems_set_errno_and_return_minus_one( ENOTDIR );
} else if ( node->type == IMFS_SYM_LINK ) {
9f04: e3530004 cmp r3, #4
9f08: 0a00007a beq a0f8 <IMFS_eval_path+0x2d8>
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
9f0c: e3530001 cmp r3, #1
9f10: 1a000069 bne a0bc <IMFS_eval_path+0x29c>
/*
* Find the token name in the current node.
*/
node = IMFS_find_match_in_dir( node, token );
9f14: e1a00006 mov r0, r6
9f18: e1a01008 mov r1, r8
9f1c: eb00023e bl a81c <IMFS_find_match_in_dir>
if ( !node )
9f20: e2506000 subs r6, r0, #0
9f24: 0a00004b beq a058 <IMFS_eval_path+0x238>
* file system and not the IMFS. For example the IMFS length is
* limited. If the token is a parent directory move back up otherwise
* set loc to the new fs root node and let them finish evaluating the
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
9f28: e596304c ldr r3, [r6, #76] ; 0x4c
9f2c: e3530001 cmp r3, #1
9f30: 0a000018 beq 9f98 <IMFS_eval_path+0x178>
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
9f34: e5876000 str r6, [r7]
break;
9f38: eaffffc3 b 9e4c <IMFS_eval_path+0x2c>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
9f3c: e59f11f4 ldr r1, [pc, #500] ; a138 <IMFS_eval_path+0x318>
9f40: e5912000 ldr r2, [r1]
9f44: e5922018 ldr r2, [r2, #24]
9f48: e1520003 cmp r2, r3
9f4c: 0affffbe beq 9e4c <IMFS_eval_path+0x2c>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access) {
9f50: e597c010 ldr ip, [r7, #16]
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
9f54: e59c201c ldr r2, [ip, #28]
9f58: e1520003 cmp r2, r3
9f5c: 0a00006e beq a11c <IMFS_eval_path+0x2fc>
return (*pathloc->ops->evalpath_h)(&(pathname[i-len]),
pathnamelen+len,
flags,pathloc);
}
} else {
if ( !node->Parent )
9f60: e5936008 ldr r6, [r3, #8]
9f64: e3560000 cmp r6, #0
9f68: 1afffff1 bne 9f34 <IMFS_eval_path+0x114>
rtems_set_errno_and_return_minus_one( ENOENT );
9f6c: eb0010d3 bl e2c0 <__errno>
9f70: e580b000 str fp, [r0]
9f74: e3e0b000 mvn fp, #0
9f78: ea000003 b 9f8c <IMFS_eval_path+0x16c>
case IMFS_NO_MORE_PATH:
case IMFS_CURRENT_DIR:
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
9f7c: eb0010cf bl e2c0 <__errno>
9f80: e3a0305b mov r3, #91 ; 0x5b
9f84: e5803000 str r3, [r0]
9f88: e3e0b000 mvn fp, #0
if ( !IMFS_evaluate_permission( pathloc, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
9f8c: e1a0000b mov r0, fp
9f90: e28dd02c add sp, sp, #44 ; 0x2c
9f94: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* file system and not the IMFS. For example the IMFS length is
* limited. If the token is a parent directory move back up otherwise
* set loc to the new fs root node and let them finish evaluating the
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
9f98: e596305c ldr r3, [r6, #92] ; 0x5c
9f9c: e3530000 cmp r3, #0
9fa0: 108ab005 addne fp, sl, r5
9fa4: 0affffe2 beq 9f34 <IMFS_eval_path+0x114>
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
9fa8: e5db0000 ldrb r0, [fp]
9fac: ebffe41a bl 301c <rtems_filesystem_is_separator>
9fb0: e3500000 cmp r0, #0
++(*index);
--(*len);
9fb4: e1a0c00b mov ip, fp
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
9fb8: 0a00000c beq 9ff0 <IMFS_eval_path+0x1d0>
9fbc: e5db3000 ldrb r3, [fp]
9fc0: e3530000 cmp r3, #0
9fc4: 0a000041 beq a0d0 <IMFS_eval_path+0x2b0>
9fc8: e3540000 cmp r4, #0
9fcc: e28bb001 add fp, fp, #1
9fd0: 0a000007 beq 9ff4 <IMFS_eval_path+0x1d4>
9fd4: e5db0000 ldrb r0, [fp]
9fd8: ebffe40f bl 301c <rtems_filesystem_is_separator>
9fdc: e3500000 cmp r0, #0
++(*index);
9fe0: e2855001 add r5, r5, #1
--(*len);
9fe4: e2444001 sub r4, r4, #1
9fe8: e1a0c00b mov ip, fp
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
9fec: 1afffff2 bne 9fbc <IMFS_eval_path+0x19c>
9ff0: e5db3000 ldrb r3, [fp]
* set loc to the new fs root node and let them finish evaluating the
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( pathname, &pathnamelen, &i);
if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {
9ff4: e353002e cmp r3, #46 ; 0x2e
9ff8: 1a000034 bne a0d0 <IMFS_eval_path+0x2b0>
9ffc: e08a3005 add r3, sl, r5
a000: e5d33001 ldrb r3, [r3, #1]
a004: e353002e cmp r3, #46 ; 0x2e
a008: 1a000030 bne a0d0 <IMFS_eval_path+0x2b0>
pathnamelen,
flags, pathloc );
}
i += 2;
pathnamelen -= 2;
node = node->Parent;
a00c: e5966008 ldr r6, [r6, #8]
*pathloc = node->info.directory.mt_fs->mt_fs_root;
return (*pathloc->ops->evalpath_h)( &pathname[i],
pathnamelen,
flags, pathloc );
}
i += 2;
a010: e2855002 add r5, r5, #2
pathnamelen -= 2;
a014: e2444002 sub r4, r4, #2
/*
* Set the node access to the point we have found.
*/
pathloc->node_access = node;
a018: e5876000 str r6, [r7]
a01c: eaffff8a b 9e4c <IMFS_eval_path+0x2c>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
a020: e1a00007 mov r0, r7
a024: ebffff25 bl 9cc0 <IMFS_evaluate_permission>
a028: e3500000 cmp r0, #0
a02c: 0affff9f beq 9eb0 <IMFS_eval_path+0x90>
a030: e5973000 ldr r3, [r7]
a034: eaffffa5 b 9ed0 <IMFS_eval_path+0xb0>
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
IMFS_evaluate_hard_link( pathloc, 0 );
a038: e1a00007 mov r0, r7
a03c: e3a01000 mov r1, #0
a040: ebffff2e bl 9d00 <IMFS_evaluate_hard_link>
node = pathloc->node_access;
a044: e5976000 ldr r6, [r7]
if ( !node )
a048: e3560000 cmp r6, #0
a04c: 0a00001a beq a0bc <IMFS_eval_path+0x29c>
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
node = pathloc->node_access;
a050: e596304c ldr r3, [r6, #76] ; 0x4c
a054: eaffffac b 9f0c <IMFS_eval_path+0xec>
*/
node = IMFS_find_match_in_dir( node, token );
if ( !node )
rtems_set_errno_and_return_minus_one( ENOENT );
a058: eb001098 bl e2c0 <__errno>
a05c: e3a03002 mov r3, #2
a060: e5803000 str r3, [r0]
a064: e3e0b000 mvn fp, #0
a068: eaffffc7 b 9f8c <IMFS_eval_path+0x16c>
*
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
a06c: e593c05c ldr ip, [r3, #92] ; 0x5c
a070: e35c0000 cmp ip, #0
a074: 0affff85 beq 9e90 <IMFS_eval_path+0x70>
*pathloc = node->info.directory.mt_fs->mt_fs_root;
a078: e28cc01c add ip, ip, #28 <== NOT EXECUTED
a07c: e8bc000f ldm ip!, {r0, r1, r2, r3}
a080: e1a0e007 mov lr, r7
a084: e8ae000f stmia lr!, {r0, r1, r2, r3}
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
a088: e59d1028 ldr r1, [sp, #40] ; 0x28
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
a08c: e59c2000 ldr r2, [ip]
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
a090: e0610005 rsb r0, r1, r5
* NOTE: The behavior of stat() on a mount point appears to be questionable.
*/
if ( node->type == IMFS_DIRECTORY ) {
if ( node->info.directory.mt_fs != NULL ) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
a094: e58e2000 str r2, [lr]
return (*pathloc->ops->evalpath_h)( &pathname[i-len],
a098: e08a0000 add r0, sl, r0
a09c: e0841001 add r1, r4, r1
a0a0: e59d2000 ldr r2, [sp]
a0a4: e1a03007 mov r3, r7
a0a8: e597c00c ldr ip, [r7, #12]
a0ac: e1a0e00f mov lr, pc
a0b0: e59cf000 ldr pc, [ip]
a0b4: e1a0b000 mov fp, r0
a0b8: eaffffb3 b 9f8c <IMFS_eval_path+0x16c>
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
a0bc: eb00107f bl e2c0 <__errno>
a0c0: e3a03014 mov r3, #20
a0c4: e5803000 str r3, [r0]
a0c8: e3e0b000 mvn fp, #0
a0cc: eaffffae b 9f8c <IMFS_eval_path+0x16c>
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( pathname, &pathnamelen, &i);
if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
a0d0: e596e05c ldr lr, [r6, #92] ; 0x5c
a0d4: e28ee01c add lr, lr, #28
a0d8: e8be000f ldm lr!, {r0, r1, r2, r3}
a0dc: e1a05007 mov r5, r7
a0e0: e8a5000f stmia r5!, {r0, r1, r2, r3}
a0e4: e59e2000 ldr r2, [lr]
return (*pathloc->ops->evalpath_h)( &pathname[i],
a0e8: e1a0000c mov r0, ip
* path.
*/
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( pathname, &pathnamelen, &i);
if ((pathname[i] != '.') || (pathname[i + 1] != '.')) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
a0ec: e5852000 str r2, [r5]
return (*pathloc->ops->evalpath_h)( &pathname[i],
a0f0: e1a01004 mov r1, r4
a0f4: eaffffe9 b a0a0 <IMFS_eval_path+0x280>
if ( !node )
rtems_set_errno_and_return_minus_one( ENOTDIR );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
a0f8: e1a00007 mov r0, r7
a0fc: e3a01000 mov r1, #0
a100: ebffff16 bl 9d60 <IMFS_evaluate_sym_link>
node = pathloc->node_access;
if ( result == -1 )
a104: e3700001 cmn r0, #1
if ( !node )
rtems_set_errno_and_return_minus_one( ENOTDIR );
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
a108: e1a0b000 mov fp, r0
node = pathloc->node_access;
a10c: e5976000 ldr r6, [r7]
if ( result == -1 )
a110: 0affff9d beq 9f8c <IMFS_eval_path+0x16c>
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_sym_link( pathloc, 0 );
node = pathloc->node_access;
a114: e596304c ldr r3, [r6, #76] ; 0x4c
a118: eaffff7b b 9f0c <IMFS_eval_path+0xec>
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break; /* Throw out the .. in this case */
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
a11c: e28cc008 add ip, ip, #8
a120: eaffffd5 b a07c <IMFS_eval_path+0x25c>
char token[ IMFS_NAME_MAX + 1 ];
IMFS_jnode_t *node;
int result;
if ( !rtems_libio_is_valid_perms( flags ) ) {
assert( 0 );
a124: e59f0010 ldr r0, [pc, #16] ; a13c <IMFS_eval_path+0x31c> <== NOT EXECUTED
a128: e3a01f82 mov r1, #520 ; 0x208 <== NOT EXECUTED
a12c: e59f200c ldr r2, [pc, #12] ; a140 <IMFS_eval_path+0x320> <== NOT EXECUTED
a130: e59f300c ldr r3, [pc, #12] ; a144 <IMFS_eval_path+0x324> <== NOT EXECUTED
a134: eb000286 bl ab54 <__assert_func> <== NOT EXECUTED
0000a21c <IMFS_evaluate_for_make>:
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
a21c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
a220: e24dd02c sub sp, sp, #44 ; 0x2c
a224: e1a07001 mov r7, r1
/*
* This was filled in by the caller and is valid in the
* mount table.
*/
node = pathloc->node_access;
a228: e5916000 ldr r6, [r1]
int IMFS_evaluate_for_make(
const char *path, /* IN */
rtems_filesystem_location_info_t *pathloc, /* IN/OUT */
const char **name /* OUT */
)
{
a22c: e58d2000 str r2, [sp]
a230: e1a0a000 mov sl, r0
node = pathloc->node_access;
/*
* Get the path length.
*/
pathlen = strlen( path );
a234: eb001426 bl f2d4 <strlen>
a238: e3a05000 mov r5, #0
a23c: e28d8004 add r8, sp, #4
a240: e1a04000 mov r4, r0
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
a244: e28d3028 add r3, sp, #40 ; 0x28
a248: e08a0005 add r0, sl, r5
a24c: e1a01004 mov r1, r4
a250: e1a02008 mov r2, r8
a254: eb00019f bl a8d8 <IMFS_get_token>
pathlen -= len;
i += len;
if ( !pathloc->node_access )
a258: e5973000 ldr r3, [r7]
a25c: e3530000 cmp r3, #0
* Evaluate all tokens until we are done or an error occurs.
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
a260: e1a09000 mov r9, r0
pathlen -= len;
a264: e59db028 ldr fp, [sp, #40] ; 0x28
i += len;
if ( !pathloc->node_access )
a268: 0a00003b beq a35c <IMFS_evaluate_for_make+0x140>
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
a26c: e3500000 cmp r0, #0
a270: 1a000006 bne a290 <IMFS_evaluate_for_make+0x74>
pathloc->node_access = node;
}
break;
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
a274: eb001011 bl e2c0 <__errno>
a278: e3a03011 mov r3, #17
a27c: e5803000 str r3, [r0]
a280: e3e06000 mvn r6, #0
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
a284: e1a00006 mov r0, r6
a288: e28dd02c add sp, sp, #44 ; 0x2c
a28c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
a290: e596104c ldr r1, [r6, #76] ; 0x4c
a294: e3510001 cmp r1, #1
a298: 0a000052 beq a3e8 <IMFS_evaluate_for_make+0x1cc>
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
i += len;
a29c: e085500b add r5, r5, fp
*/
while( !done ) {
type = IMFS_get_token( &path[i], pathlen, token, &len );
pathlen -= len;
a2a0: e06b4004 rsb r4, fp, r4
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
rtems_set_errno_and_return_minus_one( EACCES );
node = pathloc->node_access;
a2a4: e1a06003 mov r6, r3
switch( type ) {
a2a8: e3590004 cmp r9, #4
a2ac: 979ff109 ldrls pc, [pc, r9, lsl #2]
a2b0: eaffffe3 b a244 <IMFS_evaluate_for_make+0x28> <== NOT EXECUTED
a2b4: 0000a274 .word 0x0000a274 <== NOT EXECUTED
a2b8: 0000a244 .word 0x0000a244 <== NOT EXECUTED
a2bc: 0000a32c .word 0x0000a32c <== NOT EXECUTED
a2c0: 0000a2dc .word 0x0000a2dc <== NOT EXECUTED
a2c4: 0000a2c8 .word 0x0000a2c8 <== NOT EXECUTED
case IMFS_NO_MORE_PATH:
rtems_set_errno_and_return_minus_one( EEXIST );
break;
case IMFS_INVALID_TOKEN:
rtems_set_errno_and_return_minus_one( ENAMETOOLONG );
a2c8: eb000ffc bl e2c0 <__errno>
a2cc: e3a0305b mov r3, #91 ; 0x5b
a2d0: e5803000 str r3, [r0]
a2d4: e3e06000 mvn r6, #0
a2d8: eaffffe9 b a284 <IMFS_evaluate_for_make+0x68>
case IMFS_NAME:
/*
* If we are at a link follow it.
*/
if ( node->type == IMFS_HARD_LINK ) {
a2dc: e593304c ldr r3, [r3, #76] ; 0x4c
a2e0: e3530003 cmp r3, #3
a2e4: 0a00006c beq a49c <IMFS_evaluate_for_make+0x280>
result = IMFS_evaluate_link( pathloc, 0 );
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
a2e8: e3530004 cmp r3, #4
a2ec: 0a00006a beq a49c <IMFS_evaluate_for_make+0x280>
if ( result == -1 )
return -1;
}
node = pathloc->node_access;
if ( !node )
a2f0: e3560000 cmp r6, #0
a2f4: 0a000063 beq a488 <IMFS_evaluate_for_make+0x26c>
/*
* Only a directory can be decended into.
*/
if ( node->type != IMFS_DIRECTORY )
a2f8: e596304c ldr r3, [r6, #76] ; 0x4c
a2fc: e3530001 cmp r3, #1
a300: 1a000060 bne a488 <IMFS_evaluate_for_make+0x26c>
/*
* Find the token name in the present location.
*/
node = IMFS_find_match_in_dir( node, token );
a304: e1a00006 mov r0, r6
a308: e1a01008 mov r1, r8
a30c: eb000142 bl a81c <IMFS_find_match_in_dir>
/*
* If there is no node we have found the name of the node we
* wish to create.
*/
if ( ! node )
a310: e2506000 subs r6, r0, #0
a314: 0a000039 beq a400 <IMFS_evaluate_for_make+0x1e4>
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
a318: e596304c ldr r3, [r6, #76] ; 0x4c
a31c: e3530001 cmp r3, #1
a320: 0a000012 beq a370 <IMFS_evaluate_for_make+0x154>
i += 2;
pathlen -= 2;
node = node->Parent;
}
pathloc->node_access = node;
a324: e5876000 str r6, [r7]
a328: eaffffc5 b a244 <IMFS_evaluate_for_make+0x28>
case IMFS_UP_DIR:
/*
* Am I at the root of all filesystems? (chroot'ed?)
*/
if ( pathloc->node_access == rtems_filesystem_root.node_access )
a32c: e59f11ec ldr r1, [pc, #492] ; a520 <IMFS_evaluate_for_make+0x304>
a330: e5912000 ldr r2, [r1]
a334: e5922018 ldr r2, [r2, #24]
a338: e1520003 cmp r2, r3
a33c: 0affffc0 beq a244 <IMFS_evaluate_for_make+0x28>
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access == pathloc->mt_entry->mt_fs_root.node_access){
a340: e597c010 ldr ip, [r7, #16]
a344: e59c201c ldr r2, [ip, #28]
a348: e1520003 cmp r2, r3
a34c: 0a000069 beq a4f8 <IMFS_evaluate_for_make+0x2dc>
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
}
} else {
if ( !node->Parent )
a350: e5936008 ldr r6, [r3, #8]
a354: e3560000 cmp r6, #0
a358: 1afffff1 bne a324 <IMFS_evaluate_for_make+0x108>
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
if ( !IMFS_is_separator( path[ i ] ) )
rtems_set_errno_and_return_minus_one( ENOENT );
a35c: eb000fd7 bl e2c0 <__errno>
a360: e3a03002 mov r3, #2
a364: e5803000 str r3, [r0]
a368: e3e06000 mvn r6, #0
a36c: eaffffc4 b a284 <IMFS_evaluate_for_make+0x68>
*/
if ( ! node )
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
a370: e596305c ldr r3, [r6, #92] ; 0x5c
a374: e3530000 cmp r3, #0
a378: 108a9005 addne r9, sl, r5
a37c: 1a000008 bne a3a4 <IMFS_evaluate_for_make+0x188>
a380: eaffffe7 b a324 <IMFS_evaluate_for_make+0x108>
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
a384: e5d93000 ldrb r3, [r9]
a388: e3530000 cmp r3, #0
a38c: 0a00004a beq a4bc <IMFS_evaluate_for_make+0x2a0>
a390: e3540000 cmp r4, #0
a394: e2899001 add r9, r9, #1
a398: 0a000007 beq a3bc <IMFS_evaluate_for_make+0x1a0>
++(*index);
a39c: e2855001 add r5, r5, #1
--(*len);
a3a0: e2444001 sub r4, r4, #1
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
a3a4: e5d90000 ldrb r0, [r9]
a3a8: ebffe31b bl 301c <rtems_filesystem_is_separator>
a3ac: e3500000 cmp r0, #0
++(*index);
--(*len);
a3b0: e1a0c009 mov ip, r9
const char *path, /* IN */
size_t *len, /* IN/OUT */
int *index /* IN/OUT */
)
{
while ( IMFS_is_separator( path[*index] ) && path[*index] && *len ) {
a3b4: 1afffff2 bne a384 <IMFS_evaluate_for_make+0x168>
a3b8: e5d93000 ldrb r3, [r9]
if ( ! node )
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( path, &pathlen, &i);
if ((path[i] != '.') || (path[i + 1] != '.')) {
a3bc: e353002e cmp r3, #46 ; 0x2e
a3c0: 1a00003d bne a4bc <IMFS_evaluate_for_make+0x2a0>
a3c4: e08a3005 add r3, sl, r5
a3c8: e5d33001 ldrb r3, [r3, #1]
a3cc: e353002e cmp r3, #46 ; 0x2e
a3d0: 1a000039 bne a4bc <IMFS_evaluate_for_make+0x2a0>
pathloc,
name );
}
i += 2;
pathlen -= 2;
node = node->Parent;
a3d4: e5966008 ldr r6, [r6, #8]
*pathloc = node->info.directory.mt_fs->mt_fs_root;
return (*pathloc->ops->evalformake_h)( &path[i],
pathloc,
name );
}
i += 2;
a3d8: e2855002 add r5, r5, #2
pathlen -= 2;
a3dc: e2444002 sub r4, r4, #2
node = node->Parent;
}
pathloc->node_access = node;
a3e0: e5876000 str r6, [r7]
a3e4: eaffff96 b a244 <IMFS_evaluate_for_make+0x28>
* I cannot move out of this directory without execute permission.
*/
if ( type != IMFS_NO_MORE_PATH )
if ( node->type == IMFS_DIRECTORY )
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_SEARCH ) )
a3e8: e1a00007 mov r0, r7
a3ec: ebfffe33 bl 9cc0 <IMFS_evaluate_permission>
a3f0: e3500000 cmp r0, #0
a3f4: 0a00001e beq a474 <IMFS_evaluate_for_make+0x258>
a3f8: e5973000 ldr r3, [r7]
a3fc: eaffffa6 b a29c <IMFS_evaluate_for_make+0x80>
case IMFS_CURRENT_DIR:
break;
}
}
*name = &path[ i - len ];
a400: e59d3028 ldr r3, [sp, #40] ; 0x28
a404: e59de000 ldr lr, [sp]
a408: e0633005 rsb r3, r3, r5
a40c: e08a3003 add r3, sl, r3
a410: e58e3000 str r3, [lr]
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++) {
a414: e7da0005 ldrb r0, [sl, r5]
a418: e3500000 cmp r0, #0
a41c: 0a000008 beq a444 <IMFS_evaluate_for_make+0x228>
a420: e08a5005 add r5, sl, r5
a424: ea000002 b a434 <IMFS_evaluate_for_make+0x218>
a428: e5f50001 ldrb r0, [r5, #1]!
a42c: e3500000 cmp r0, #0
a430: 0a000003 beq a444 <IMFS_evaluate_for_make+0x228>
if ( !IMFS_is_separator( path[ i ] ) )
a434: ebffe2f8 bl 301c <rtems_filesystem_is_separator>
a438: e3500000 cmp r0, #0
a43c: 1afffff9 bne a428 <IMFS_evaluate_for_make+0x20c>
a440: eaffffc5 b a35c <IMFS_evaluate_for_make+0x140>
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
a444: e1a00007 mov r0, r7
a448: ebfffdf6 bl 9c28 <IMFS_Set_handlers>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
a44c: e5973000 ldr r3, [r7]
a450: e593304c ldr r3, [r3, #76] ; 0x4c
a454: e3530001 cmp r3, #1
/*
* Verify we can execute and write to this directory.
*/
result = IMFS_Set_handlers( pathloc );
a458: e1a06000 mov r6, r0
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
a45c: 1a000009 bne a488 <IMFS_evaluate_for_make+0x26c>
/*
* We must have Write and execute permission on the returned node.
*/
if ( !IMFS_evaluate_permission( pathloc, RTEMS_LIBIO_PERMS_WX ) )
a460: e1a00007 mov r0, r7
a464: e3a01003 mov r1, #3
a468: ebfffe14 bl 9cc0 <IMFS_evaluate_permission>
a46c: e3500000 cmp r0, #0
a470: 1affff83 bne a284 <IMFS_evaluate_for_make+0x68>
rtems_set_errno_and_return_minus_one( EACCES );
a474: eb000f91 bl e2c0 <__errno>
a478: e3a0300d mov r3, #13
a47c: e5803000 str r3, [r0]
a480: e3e06000 mvn r6, #0
a484: eaffff7e b a284 <IMFS_evaluate_for_make+0x68>
/*
* The returned node must be a directory
*/
node = pathloc->node_access;
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
a488: eb000f8c bl e2c0 <__errno>
a48c: e3a03014 mov r3, #20
a490: e5803000 str r3, [r0]
a494: e3e06000 mvn r6, #0
a498: eaffff79 b a284 <IMFS_evaluate_for_make+0x68>
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
a49c: e1a00007 mov r0, r7
a4a0: e3a01000 mov r1, #0
a4a4: ebffff27 bl a148 <IMFS_evaluate_link>
if ( result == -1 )
a4a8: e3700001 cmn r0, #1
if ( result == -1 )
return -1;
} else if ( node->type == IMFS_SYM_LINK ) {
result = IMFS_evaluate_link( pathloc, 0 );
a4ac: e1a06000 mov r6, r0
if ( result == -1 )
a4b0: 0affff73 beq a284 <IMFS_evaluate_for_make+0x68>
a4b4: e5976000 ldr r6, [r7]
a4b8: eaffff8c b a2f0 <IMFS_evaluate_for_make+0xd4>
done = true;
else {
if (( node->type == IMFS_DIRECTORY ) && ( node->info.directory.mt_fs != NULL )) {
IMFS_skip_separator( path, &pathlen, &i);
if ((path[i] != '.') || (path[i + 1] != '.')) {
*pathloc = node->info.directory.mt_fs->mt_fs_root;
a4bc: e596e05c ldr lr, [r6, #92] ; 0x5c
a4c0: e28ee01c add lr, lr, #28
a4c4: e8be000f ldm lr!, {r0, r1, r2, r3}
a4c8: e1a04007 mov r4, r7
a4cc: e8a4000f stmia r4!, {r0, r1, r2, r3}
a4d0: e59e2000 ldr r2, [lr]
a4d4: e5842000 str r2, [r4]
return (*pathloc->ops->evalformake_h)( &path[i],
a4d8: e1a0000c mov r0, ip
a4dc: e1a01007 mov r1, r7
a4e0: e59d2000 ldr r2, [sp]
a4e4: e597300c ldr r3, [r7, #12]
a4e8: e1a0e00f mov lr, pc
a4ec: e593f004 ldr pc, [r3, #4]
a4f0: e1a06000 mov r6, r0
a4f4: eaffff62 b a284 <IMFS_evaluate_for_make+0x68>
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
a4f8: e28cc008 add ip, ip, #8
a4fc: e8bc000f ldm ip!, {r0, r1, r2, r3}
a500: e1a04007 mov r4, r7
a504: e8a4000f stmia r4!, {r0, r1, r2, r3}
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
a508: e59d0028 ldr r0, [sp, #40] ; 0x28
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
a50c: e59c2000 ldr r2, [ip]
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
a510: e0600005 rsb r0, r0, r5
if ( pathloc->node_access == rtems_filesystem_root.node_access ) {
break;
} else {
*pathloc = pathloc->mt_entry->mt_point_node;
a514: e5842000 str r2, [r4]
return (*pathloc->ops->evalformake_h)( &path[i-len], pathloc, name );
a518: e08a0000 add r0, sl, r0
a51c: eaffffee b a4dc <IMFS_evaluate_for_make+0x2c0>
00009d00 <IMFS_evaluate_hard_link>:
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
IMFS_jnode_t *jnode = node->node_access;
9d00: e5903000 ldr r3, [r0]
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_HARD_LINK )
9d04: e593204c ldr r2, [r3, #76] ; 0x4c
9d08: e3520003 cmp r2, #3
int IMFS_evaluate_hard_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
9d0c: e92d4030 push {r4, r5, lr}
9d10: e1a04000 mov r4, r0
9d14: e1a05001 mov r5, r1
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_HARD_LINK )
9d18: 1a00000d bne 9d54 <IMFS_evaluate_hard_link+0x54>
/*
* Set the hard link value and the handlers.
*/
node->node_access = jnode->info.hard_link.link_node;
9d1c: e5933050 ldr r3, [r3, #80] ; 0x50
9d20: e5803000 str r3, [r0]
IMFS_Set_handlers( node );
9d24: ebffffbf bl 9c28 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
9d28: e1a00004 mov r0, r4
9d2c: e1a01005 mov r1, r5
9d30: ebffffe2 bl 9cc0 <IMFS_evaluate_permission>
9d34: e3500000 cmp r0, #0
9d38: 13a00000 movne r0, #0
9d3c: 18bd8030 popne {r4, r5, pc}
rtems_set_errno_and_return_minus_one( EACCES );
9d40: eb00115e bl e2c0 <__errno> <== NOT EXECUTED
9d44: e3a0300d mov r3, #13 <== NOT EXECUTED
9d48: e5803000 str r3, [r0] <== NOT EXECUTED
9d4c: e3e00000 mvn r0, #0 <== NOT EXECUTED
return result;
}
9d50: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_HARD_LINK )
rtems_fatal_error_occurred (0xABCD0000);
9d54: e3a0032b mov r0, #-1409286144 ; 0xac000000 <== NOT EXECUTED
9d58: e2400833 sub r0, r0, #3342336 ; 0x330000 <== NOT EXECUTED
9d5c: ebfff01f bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
00009cc0 <IMFS_evaluate_permission>:
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
9cc0: e3d13007 bics r3, r1, #7
int IMFS_evaluate_permission(
rtems_filesystem_location_info_t *node,
int flags
)
{
9cc4: e52de004 push {lr} ; (str lr, [sp, #-4]!)
uid_t st_uid;
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
9cc8: 1a000007 bne 9cec <IMFS_evaluate_permission+0x2c>
/*
* If all of the flags are set we have permission
* to do this.
*/
if ( ( flags_to_test & jnode->st_mode) == flags_to_test )
9ccc: e5903000 ldr r3, [r0]
9cd0: e5930030 ldr r0, [r3, #48] ; 0x30
9cd4: e1a01301 lsl r1, r1, #6
9cd8: e0010000 and r0, r1, r0
9cdc: e1510000 cmp r1, r0
9ce0: 13a00000 movne r0, #0
9ce4: 03a00001 moveq r0, #1
return 1;
return 0;
}
9ce8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
gid_t st_gid;
IMFS_jnode_t *jnode;
int flags_to_test;
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
9cec: eb001173 bl e2c0 <__errno> <== NOT EXECUTED
9cf0: e3a03001 mov r3, #1 <== NOT EXECUTED
9cf4: e5803000 str r3, [r0] <== NOT EXECUTED
9cf8: e3e00000 mvn r0, #0 <== NOT EXECUTED
9cfc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00009d60 <IMFS_evaluate_sym_link>:
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
9d60: e92d4070 push {r4, r5, r6, lr}
IMFS_jnode_t *jnode = node->node_access;
9d64: e5906000 ldr r6, [r0]
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_SYM_LINK )
9d68: e596304c ldr r3, [r6, #76] ; 0x4c
9d6c: e3530004 cmp r3, #4
int IMFS_evaluate_sym_link(
rtems_filesystem_location_info_t *node, /* IN/OUT */
int flags /* IN */
)
{
9d70: e24dd004 sub sp, sp, #4
9d74: e1a04000 mov r4, r0
9d78: e1a05001 mov r5, r1
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_SYM_LINK )
9d7c: 1a000024 bne 9e14 <IMFS_evaluate_sym_link+0xb4>
rtems_fatal_error_occurred (0xABCD0000);
if ( !jnode->Parent )
9d80: e5963008 ldr r3, [r6, #8]
9d84: e3530000 cmp r3, #0
9d88: 0a00001e beq 9e08 <IMFS_evaluate_sym_link+0xa8>
/*
* Move the node_access to either the symbolic links parent or
* root depending on the symbolic links path.
*/
node->node_access = jnode->Parent;
9d8c: e5803000 str r3, [r0]
rtems_filesystem_get_sym_start_loc(
9d90: e1a0100d mov r1, sp
9d94: e5960050 ldr r0, [r6, #80] ; 0x50
9d98: e1a02004 mov r2, r4
9d9c: eb00053c bl b294 <rtems_filesystem_get_sym_start_loc>
/*
* Use eval path to evaluate the path of the symbolic link.
*/
result = IMFS_eval_path(
9da0: e59d3000 ldr r3, [sp]
9da4: e5966050 ldr r6, [r6, #80] ; 0x50
9da8: e0866003 add r6, r6, r3
9dac: e1a00006 mov r0, r6
9db0: eb001547 bl f2d4 <strlen>
9db4: e1a02005 mov r2, r5
9db8: e1a01000 mov r1, r0
9dbc: e1a03004 mov r3, r4
9dc0: e1a00006 mov r0, r6
9dc4: eb000015 bl 9e20 <IMFS_eval_path>
9dc8: e1a06000 mov r6, r0
strlen( &jnode->info.sym_link.name[i] ),
flags,
node
);
IMFS_Set_handlers( node );
9dcc: e1a00004 mov r0, r4
9dd0: ebffff94 bl 9c28 <IMFS_Set_handlers>
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
9dd4: e1a00004 mov r0, r4
9dd8: e1a01005 mov r1, r5
9ddc: ebffffb7 bl 9cc0 <IMFS_evaluate_permission>
9de0: e3500000 cmp r0, #0
9de4: 0a000002 beq 9df4 <IMFS_evaluate_sym_link+0x94>
rtems_set_errno_and_return_minus_one( EACCES );
return result;
}
9de8: e1a00006 mov r0, r6
9dec: e28dd004 add sp, sp, #4
9df0: e8bd8070 pop {r4, r5, r6, pc}
/*
* Verify we have the correct permissions for this node.
*/
if ( !IMFS_evaluate_permission( node, flags ) )
rtems_set_errno_and_return_minus_one( EACCES );
9df4: eb001131 bl e2c0 <__errno> <== NOT EXECUTED
9df8: e3a0300d mov r3, #13 <== NOT EXECUTED
9dfc: e5803000 str r3, [r0] <== NOT EXECUTED
9e00: e3e06000 mvn r6, #0 <== NOT EXECUTED
9e04: eafffff7 b 9de8 <IMFS_evaluate_sym_link+0x88> <== NOT EXECUTED
if ( jnode->type != IMFS_SYM_LINK )
rtems_fatal_error_occurred (0xABCD0000);
if ( !jnode->Parent )
rtems_fatal_error_occurred( 0xBAD00000 );
9e08: e3a004ba mov r0, #-1174405120 ; 0xba000000 <== NOT EXECUTED
9e0c: e280060d add r0, r0, #13631488 ; 0xd00000 <== NOT EXECUTED
9e10: ebffeff2 bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
/*
* Check for things that should never happen.
*/
if ( jnode->type != IMFS_SYM_LINK )
rtems_fatal_error_occurred (0xABCD0000);
9e14: e3a0032b mov r0, #-1409286144 ; 0xac000000 <== NOT EXECUTED
9e18: e2400833 sub r0, r0, #3342336 ; 0x330000 <== NOT EXECUTED
9e1c: ebffefef bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000a6b0 <IMFS_fifo_close>:
}
int IMFS_fifo_close(
rtems_libio_t *iop
)
{
a6b0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->file_info;
a6b4: e5905038 ldr r5, [r0, #56] ; 0x38 <== NOT EXECUTED
int err = pipe_release(&JNODE2PIPE(jnode), iop);
a6b8: e1a01000 mov r1, r0 <== NOT EXECUTED
}
int IMFS_fifo_close(
rtems_libio_t *iop
)
{
a6bc: e1a04000 mov r4, r0 <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->file_info;
int err = pipe_release(&JNODE2PIPE(jnode), iop);
a6c0: e2850050 add r0, r5, #80 ; 0x50 <== NOT EXECUTED
a6c4: ebfffb8f bl 9508 <pipe_release> <== NOT EXECUTED
if (! err) {
a6c8: e2506000 subs r6, r0, #0 <== NOT EXECUTED
a6cc: 0a000002 beq a6dc <IMFS_fifo_close+0x2c> <== NOT EXECUTED
/* Free jnode if file is already unlinked and no one opens it */
if (! rtems_libio_is_file_open(jnode) && jnode->st_nlink < 1)
free(jnode);
}
IMFS_FIFO_RETURN(err);
a6d0: ba00000e blt a710 <IMFS_fifo_close+0x60> <== NOT EXECUTED
}
a6d4: e1a00006 mov r0, r6 <== NOT EXECUTED
a6d8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->file_info;
int err = pipe_release(&JNODE2PIPE(jnode), iop);
if (! err) {
iop->flags &= ~LIBIO_FLAGS_OPEN;
a6dc: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
a6e0: e3c33c01 bic r3, r3, #256 ; 0x100 <== NOT EXECUTED
a6e4: e5843014 str r3, [r4, #20] <== NOT EXECUTED
/* Free jnode if file is already unlinked and no one opens it */
if (! rtems_libio_is_file_open(jnode) && jnode->st_nlink < 1)
a6e8: e1a00005 mov r0, r5 <== NOT EXECUTED
a6ec: eb0001a8 bl ad94 <rtems_libio_is_file_open> <== NOT EXECUTED
a6f0: e3500000 cmp r0, #0 <== NOT EXECUTED
a6f4: 1afffff6 bne a6d4 <IMFS_fifo_close+0x24> <== NOT EXECUTED
a6f8: e1d533b4 ldrh r3, [r5, #52] ; 0x34 <== NOT EXECUTED
a6fc: e3530000 cmp r3, #0 <== NOT EXECUTED
a700: 1afffff3 bne a6d4 <IMFS_fifo_close+0x24> <== NOT EXECUTED
free(jnode);
a704: e1a00005 mov r0, r5 <== NOT EXECUTED
a708: ebffde66 bl 20a8 <free> <== NOT EXECUTED
a70c: eafffff0 b a6d4 <IMFS_fifo_close+0x24> <== NOT EXECUTED
}
IMFS_FIFO_RETURN(err);
a710: eb000eea bl e2c0 <__errno> <== NOT EXECUTED
a714: e2666000 rsb r6, r6, #0 <== NOT EXECUTED
a718: e5806000 str r6, [r0] <== NOT EXECUTED
a71c: e3e06000 mvn r6, #0 <== NOT EXECUTED
a720: eaffffeb b a6d4 <IMFS_fifo_close+0x24> <== NOT EXECUTED
0000a57c <IMFS_fifo_ioctl>:
void *buffer
)
{
int err;
if (command == FIONBIO) {
a57c: e3a03a46 mov r3, #286720 ; 0x46000 <== NOT EXECUTED
a580: e2833e67 add r3, r3, #1648 ; 0x670 <== NOT EXECUTED
a584: e283313a add r3, r3, #-2147483634 ; 0x8000000e <== NOT EXECUTED
a588: e1510003 cmp r1, r3 <== NOT EXECUTED
int IMFS_fifo_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
a58c: e92d4010 push {r4, lr} <== NOT EXECUTED
a590: e1a03002 mov r3, r2 <== NOT EXECUTED
int err;
if (command == FIONBIO) {
a594: 0a00000a beq a5c4 <IMFS_fifo_ioctl+0x48> <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
return 0;
}
}
else
err = pipe_ioctl(LIBIO2PIPE(iop), command, buffer, iop);
a598: e590c038 ldr ip, [r0, #56] ; 0x38 <== NOT EXECUTED
a59c: e1a03000 mov r3, r0 <== NOT EXECUTED
a5a0: e59c0050 ldr r0, [ip, #80] ; 0x50 <== NOT EXECUTED
a5a4: ebfffad0 bl 90ec <pipe_ioctl> <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
a5a8: e3500000 cmp r0, #0 <== NOT EXECUTED
a5ac: a8bd8010 popge {r4, pc} <== NOT EXECUTED
a5b0: e2604000 rsb r4, r0, #0 <== NOT EXECUTED
a5b4: eb000f41 bl e2c0 <__errno> <== NOT EXECUTED
a5b8: e5804000 str r4, [r0] <== NOT EXECUTED
a5bc: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
a5c0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
)
{
int err;
if (command == FIONBIO) {
if (buffer == NULL)
a5c4: e3520000 cmp r2, #0 <== NOT EXECUTED
a5c8: 03a0400e moveq r4, #14 <== NOT EXECUTED
a5cc: 0afffff8 beq a5b4 <IMFS_fifo_ioctl+0x38> <== NOT EXECUTED
err = -EFAULT;
else {
if (*(int *)buffer)
a5d0: e5924000 ldr r4, [r2] <== NOT EXECUTED
a5d4: e3540000 cmp r4, #0 <== NOT EXECUTED
iop->flags |= LIBIO_FLAGS_NO_DELAY;
a5d8: 15903014 ldrne r3, [r0, #20] <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
a5dc: 05903014 ldreq r3, [r0, #20] <== NOT EXECUTED
if (command == FIONBIO) {
if (buffer == NULL)
err = -EFAULT;
else {
if (*(int *)buffer)
iop->flags |= LIBIO_FLAGS_NO_DELAY;
a5e0: 13833001 orrne r3, r3, #1 <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
a5e4: 03c33001 biceq r3, r3, #1 <== NOT EXECUTED
if (command == FIONBIO) {
if (buffer == NULL)
err = -EFAULT;
else {
if (*(int *)buffer)
iop->flags |= LIBIO_FLAGS_NO_DELAY;
a5e8: 15803014 strne r3, [r0, #20] <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
a5ec: 05803014 streq r3, [r0, #20] <== NOT EXECUTED
if (command == FIONBIO) {
if (buffer == NULL)
err = -EFAULT;
else {
if (*(int *)buffer)
iop->flags |= LIBIO_FLAGS_NO_DELAY;
a5f0: 13a00000 movne r0, #0 <== NOT EXECUTED
else
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
a5f4: 01a00004 moveq r0, r4 <== NOT EXECUTED
a5f8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0000a524 <IMFS_fifo_lseek>:
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
a524: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
a528: e1a0c000 mov ip, r0 <== NOT EXECUTED
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
a52c: e5900038 ldr r0, [r0, #56] ; 0x38 <== NOT EXECUTED
rtems_off64_t IMFS_fifo_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
a530: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
a534: e5900050 ldr r0, [r0, #80] ; 0x50 <== NOT EXECUTED
a538: e58dc000 str ip, [sp] <== NOT EXECUTED
a53c: ebfffacc bl 9074 <pipe_lseek> <== NOT EXECUTED
a540: e1a03000 mov r3, r0 <== NOT EXECUTED
a544: e1a04fc3 asr r4, r3, #31 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
a548: e3540000 cmp r4, #0 <== NOT EXECUTED
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
a54c: e1a05000 mov r5, r0 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
a550: ba000003 blt a564 <IMFS_fifo_lseek+0x40> <== NOT EXECUTED
}
a554: e1a01004 mov r1, r4 <== NOT EXECUTED
a558: e1a00003 mov r0, r3 <== NOT EXECUTED
a55c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
a560: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
rtems_off64_t offset,
int whence
)
{
off_t err = pipe_lseek(LIBIO2PIPE(iop), offset, whence, iop);
IMFS_FIFO_RETURN(err);
a564: eb000f55 bl e2c0 <__errno> <== NOT EXECUTED
a568: e2655000 rsb r5, r5, #0 <== NOT EXECUTED
a56c: e5805000 str r5, [r0] <== NOT EXECUTED
a570: e3e03000 mvn r3, #0 <== NOT EXECUTED
a574: e3e04000 mvn r4, #0 <== NOT EXECUTED
a578: eafffff5 b a554 <IMFS_fifo_lseek+0x30> <== NOT EXECUTED
0000a658 <IMFS_fifo_read>:
ssize_t IMFS_fifo_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
a658: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->file_info;
a65c: e5904038 ldr r4, [r0, #56] ; 0x38 <== NOT EXECUTED
ssize_t IMFS_fifo_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
a660: e1a03000 mov r3, r0 <== NOT EXECUTED
a664: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->file_info;
int err = pipe_read(JNODE2PIPE(jnode), buffer, count, iop);
a668: e5940050 ldr r0, [r4, #80] ; 0x50 <== NOT EXECUTED
a66c: ebfffb37 bl 9350 <pipe_read> <== NOT EXECUTED
if (err > 0)
a670: e2505000 subs r5, r0, #0 <== NOT EXECUTED
a674: da000007 ble a698 <IMFS_fifo_read+0x40> <== NOT EXECUTED
IMFS_update_atime(jnode);
a678: e1a0000d mov r0, sp <== NOT EXECUTED
a67c: e3a01000 mov r1, #0 <== NOT EXECUTED
a680: ebffdeb1 bl 214c <gettimeofday> <== NOT EXECUTED
a684: e59d3000 ldr r3, [sp] <== NOT EXECUTED
a688: e5843040 str r3, [r4, #64] ; 0x40 <== NOT EXECUTED
IMFS_FIFO_RETURN(err);
}
a68c: e1a00005 mov r0, r5 <== NOT EXECUTED
a690: e28dd008 add sp, sp, #8 <== NOT EXECUTED
a694: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
int err = pipe_read(JNODE2PIPE(jnode), buffer, count, iop);
if (err > 0)
IMFS_update_atime(jnode);
IMFS_FIFO_RETURN(err);
a698: 0afffffb beq a68c <IMFS_fifo_read+0x34> <== NOT EXECUTED
a69c: eb000f07 bl e2c0 <__errno> <== NOT EXECUTED
a6a0: e2655000 rsb r5, r5, #0 <== NOT EXECUTED
a6a4: e5805000 str r5, [r0] <== NOT EXECUTED
a6a8: e3e05000 mvn r5, #0 <== NOT EXECUTED
a6ac: eafffff6 b a68c <IMFS_fifo_read+0x34> <== NOT EXECUTED
0000a5fc <IMFS_fifo_write>:
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
a5fc: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->file_info;
a600: e5904038 ldr r4, [r0, #56] ; 0x38 <== NOT EXECUTED
ssize_t IMFS_fifo_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
a604: e1a03000 mov r3, r0 <== NOT EXECUTED
a608: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
IMFS_jnode_t *jnode = iop->file_info;
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
a60c: e5940050 ldr r0, [r4, #80] ; 0x50 <== NOT EXECUTED
a610: ebffface bl 9150 <pipe_write> <== NOT EXECUTED
if (err > 0) {
a614: e2505000 subs r5, r0, #0 <== NOT EXECUTED
a618: da000008 ble a640 <IMFS_fifo_write+0x44> <== NOT EXECUTED
IMFS_mtime_ctime_update(jnode);
a61c: e1a0000d mov r0, sp <== NOT EXECUTED
a620: e3a01000 mov r1, #0 <== NOT EXECUTED
a624: ebffdec8 bl 214c <gettimeofday> <== NOT EXECUTED
a628: e59d3000 ldr r3, [sp] <== NOT EXECUTED
a62c: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
a630: e5843044 str r3, [r4, #68] ; 0x44 <== NOT EXECUTED
}
IMFS_FIFO_RETURN(err);
}
a634: e1a00005 mov r0, r5 <== NOT EXECUTED
a638: e28dd008 add sp, sp, #8 <== NOT EXECUTED
a63c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
int err = pipe_write(JNODE2PIPE(jnode), buffer, count, iop);
if (err > 0) {
IMFS_mtime_ctime_update(jnode);
}
IMFS_FIFO_RETURN(err);
a640: 0afffffb beq a634 <IMFS_fifo_write+0x38> <== NOT EXECUTED
a644: eb000f1d bl e2c0 <__errno> <== NOT EXECUTED
a648: e2655000 rsb r5, r5, #0 <== NOT EXECUTED
a64c: e5805000 str r5, [r0] <== NOT EXECUTED
a650: e3e05000 mvn r5, #0 <== NOT EXECUTED
a654: eafffff6 b a634 <IMFS_fifo_write+0x38> <== NOT EXECUTED
0000a81c <IMFS_find_match_in_dir>:
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
a81c: e92d4070 push {r4, r5, r6, lr}
/*
* Check for fatal errors. A NULL directory show a problem in the
* the IMFS code.
*/
assert( directory );
a820: e2505000 subs r5, r0, #0
IMFS_jnode_t *IMFS_find_match_in_dir(
IMFS_jnode_t *directory,
char *name
)
{
a824: e1a04001 mov r4, r1
/*
* Check for fatal errors. A NULL directory show a problem in the
* the IMFS code.
*/
assert( directory );
a828: 0a000020 beq a8b0 <IMFS_find_match_in_dir+0x94>
if ( !name )
a82c: e3510000 cmp r1, #0
a830: 0a00000c beq a868 <IMFS_find_match_in_dir+0x4c>
/*
* Check for "." and ".."
*/
if ( !strcmp( name, dotname ) )
a834: e1a00001 mov r0, r1
a838: e59f1084 ldr r1, [pc, #132] ; a8c4 <IMFS_find_match_in_dir+0xa8>
a83c: eb0011c8 bl ef64 <strcmp>
a840: e3500000 cmp r0, #0
a844: 0a000005 beq a860 <IMFS_find_match_in_dir+0x44>
return directory;
if ( !strcmp( name, dotdotname ) )
a848: e1a00004 mov r0, r4
a84c: e59f1074 ldr r1, [pc, #116] ; a8c8 <IMFS_find_match_in_dir+0xac>
a850: eb0011c3 bl ef64 <strcmp>
a854: e3500000 cmp r0, #0
return directory->Parent;
a858: 05955008 ldreq r5, [r5, #8]
*/
if ( !strcmp( name, dotname ) )
return directory;
if ( !strcmp( name, dotdotname ) )
a85c: 1a000004 bne a874 <IMFS_find_match_in_dir+0x58>
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
a860: e1a00005 mov r0, r5
a864: e8bd8070 pop {r4, r5, r6, pc}
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
a868: e3a05000 mov r5, #0
if ( !strcmp( name, the_jnode->name ) )
return the_jnode;
}
return 0;
}
a86c: e1a00005 mov r0, r5
a870: e8bd8070 pop {r4, r5, r6, pc}
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
a874: e5956050 ldr r6, [r5, #80] ; 0x50
a878: e2855054 add r5, r5, #84 ; 0x54
a87c: e1560005 cmp r6, r5
a880: 1a000003 bne a894 <IMFS_find_match_in_dir+0x78>
a884: eafffff7 b a868 <IMFS_find_match_in_dir+0x4c>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
a888: e5966000 ldr r6, [r6]
if ( !strcmp( name, dotdotname ) )
return directory->Parent;
the_chain = &directory->info.directory.Entries;
for ( the_node = the_chain->first;
a88c: e1560005 cmp r6, r5
a890: 0afffff4 beq a868 <IMFS_find_match_in_dir+0x4c>
!rtems_chain_is_tail( the_chain, the_node );
the_node = the_node->next ) {
the_jnode = (IMFS_jnode_t *) the_node;
if ( !strcmp( name, the_jnode->name ) )
a894: e1a00004 mov r0, r4
a898: e286100c add r1, r6, #12
a89c: eb0011b0 bl ef64 <strcmp>
a8a0: e3500000 cmp r0, #0
a8a4: 1afffff7 bne a888 <IMFS_find_match_in_dir+0x6c>
a8a8: e1a05006 mov r5, r6
a8ac: eaffffeb b a860 <IMFS_find_match_in_dir+0x44>
/*
* Check for fatal errors. A NULL directory show a problem in the
* the IMFS code.
*/
assert( directory );
a8b0: e59f0014 ldr r0, [pc, #20] ; a8cc <IMFS_find_match_in_dir+0xb0><== NOT EXECUTED
a8b4: e3a0102a mov r1, #42 ; 0x2a <== NOT EXECUTED
a8b8: e59f2010 ldr r2, [pc, #16] ; a8d0 <IMFS_find_match_in_dir+0xb4><== NOT EXECUTED
a8bc: e59f3010 ldr r3, [pc, #16] ; a8d4 <IMFS_find_match_in_dir+0xb8><== NOT EXECUTED
a8c0: eb0000a3 bl ab54 <__assert_func> <== NOT EXECUTED
0000a764 <IMFS_fsunmount>:
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
a764: e92d4070 push {r4, r5, r6, lr}
/*
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
a768: e1a0c000 mov ip, r0
a76c: e5bc401c ldr r4, [ip, #28]!
((IMFS_jnode_t *)( rtems_chain_head( jnode_get_control( jnode ) )->next))
int IMFS_fsunmount(
rtems_filesystem_mount_table_entry_t *temp_mt_entry
)
{
a770: e24dd014 sub sp, sp, #20
a774: e1a0e000 mov lr, r0
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
loc = temp_mt_entry->mt_fs_root;
a778: e8bc000f ldm ip!, {r0, r1, r2, r3}
a77c: e1a0600d mov r6, sp
a780: e8a6000f stmia r6!, {r0, r1, r2, r3}
a784: e59c2000 ldr r2, [ip]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
a788: e3a03000 mov r3, #0
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
loc = temp_mt_entry->mt_fs_root;
a78c: e5862000 str r2, [r6]
/*
* Set this to null to indicate that it is being unmounted.
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
a790: e58e301c str r3, [lr, #28]
* Traverse tree that starts at the mt_fs_root and deallocate memory
* associated memory space
*/
jnode = (IMFS_jnode_t *)temp_mt_entry->mt_fs_root.node_access;
loc = temp_mt_entry->mt_fs_root;
a794: e1a0500d mov r5, sp
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
a798: e1a0000d mov r0, sp
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
loc.node_access = (void *)jnode;
a79c: e58d4000 str r4, [sp]
*/
temp_mt_entry->mt_fs_root.node_access = NULL;
do {
next = jnode->Parent;
a7a0: e5946008 ldr r6, [r4, #8]
loc.node_access = (void *)jnode;
IMFS_Set_handlers( &loc );
a7a4: ebfffd1f bl 9c28 <IMFS_Set_handlers>
if ( jnode->type != IMFS_DIRECTORY ) {
a7a8: e594304c ldr r3, [r4, #76] ; 0x4c
a7ac: e3530001 cmp r3, #1
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
a7b0: e2842054 add r2, r4, #84 ; 0x54
a7b4: 1a000010 bne a7fc <IMFS_fsunmount+0x98>
a7b8: e5943050 ldr r3, [r4, #80] ; 0x50
a7bc: e1530002 cmp r3, r2
a7c0: 0a00000d beq a7fc <IMFS_fsunmount+0x98>
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
}
if ( jnode != NULL ) {
a7c4: e3540000 cmp r4, #0
a7c8: 0a000008 beq a7f0 <IMFS_fsunmount+0x8c>
if ( jnode->type == IMFS_DIRECTORY ) {
a7cc: e594304c ldr r3, [r4, #76] ; 0x4c
a7d0: e3530001 cmp r3, #1
a7d4: 1affffef bne a798 <IMFS_fsunmount+0x34>
a7d8: e5943050 ldr r3, [r4, #80] ; 0x50
a7dc: e2842054 add r2, r4, #84 ; 0x54
a7e0: e1530002 cmp r3, r2
a7e4: 0affffeb beq a798 <IMFS_fsunmount+0x34>
if ( jnode_has_children( jnode ) )
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
a7e8: e2534000 subs r4, r3, #0
a7ec: 1affffe9 bne a798 <IMFS_fsunmount+0x34>
a7f0: e3a00000 mov r0, #0
return 0;
}
a7f4: e28dd014 add sp, sp, #20
a7f8: e8bd8070 pop {r4, r5, r6, pc}
result = IMFS_unlink( NULL, &loc );
if (result != 0)
return -1;
jnode = next;
} else if ( jnode_has_no_children( jnode ) ) {
result = IMFS_unlink( NULL, &loc );
a7fc: e3a00000 mov r0, #0
a800: e1a0100d mov r1, sp
a804: ebffdca3 bl 1a98 <IMFS_unlink>
if (result != 0)
a808: e3500000 cmp r0, #0
a80c: 01a04006 moveq r4, r6
a810: 0affffeb beq a7c4 <IMFS_fsunmount+0x60>
if ( jnode->type == IMFS_DIRECTORY ) {
if ( jnode_has_children( jnode ) )
jnode = jnode_get_first_child( jnode );
}
}
} while (jnode != NULL);
a814: e3e00000 mvn r0, #0 <== NOT EXECUTED
a818: eafffff5 b a7f4 <IMFS_fsunmount+0x90> <== NOT EXECUTED
00001660 <IMFS_initialize_support>:
IMFS_jnode_t *jnode;
/*
* determine/check value for imfs_memfile_bytes_per_block
*/
IMFS_determine_bytes_per_block(&imfs_memfile_bytes_per_block,
1660: e59fc0dc ldr ip, [pc, #220] ; 1744 <IMFS_initialize_support+0xe4>
1664: e59cc000 ldr ip, [ip]
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
1668: e35c0010 cmp ip, #16
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *memfile_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers
)
{
166c: e92d41f0 push {r4, r5, r6, r7, r8, lr}
1670: e1a04000 mov r4, r0
1674: e1a07001 mov r7, r1
1678: e1a08002 mov r8, r2
167c: e1a06003 mov r6, r3
int bit_mask;
/*
* check, whether requested bytes per block is valid
*/
for (bit_mask = 16; !is_valid && (bit_mask <= 512); bit_mask <<= 1) {
1680: 0a000008 beq 16a8 <IMFS_initialize_support+0x48>
1684: e3a03000 mov r3, #0
1688: e3a02020 mov r2, #32
168c: e15c0002 cmp ip, r2
1690: e2833001 add r3, r3, #1
1694: 0a000003 beq 16a8 <IMFS_initialize_support+0x48>
1698: e3530005 cmp r3, #5
169c: e1a02082 lsl r2, r2, #1
16a0: 1afffff9 bne 168c <IMFS_initialize_support+0x2c>
16a4: e3a0c080 mov ip, #128 ; 0x80 <== NOT EXECUTED
if (bit_mask == requested_bytes_per_block) {
is_valid = true;
}
}
*dest_bytes_per_block = ((is_valid)
16a8: e59f5098 ldr r5, [pc, #152] ; 1748 <IMFS_initialize_support+0xe8>
16ac: e585c000 str ip, [r5]
/* * Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
16b0: eb0020fa bl 9aa0 <IMFS_create_root_node>
temp_mt_entry->mt_fs_root.handlers = directory_handlers; temp_mt_entry->mt_fs_root.ops = op_table; temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
16b4: e59fe090 ldr lr, [pc, #144] ; 174c <IMFS_initialize_support+0xec>
/* * Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node();
16b8: e584001c str r0, [r4, #28]
temp_mt_entry->mt_fs_root.handlers = directory_handlers; temp_mt_entry->mt_fs_root.ops = op_table; temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
16bc: e8be000f ldm lr!, {r0, r1, r2, r3}
16c0: e284c038 add ip, r4, #56 ; 0x38
16c4: e8ac000f stmia ip!, {r0, r1, r2, r3}
16c8: e8be000f ldm lr!, {r0, r1, r2, r3}
16cc: e8ac000f stmia ip!, {r0, r1, r2, r3}
16d0: e89e000f ldm lr, {r0, r1, r2, r3}
* * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node(); temp_mt_entry->mt_fs_root.handlers = directory_handlers; temp_mt_entry->mt_fs_root.ops = op_table;
16d4: e5847028 str r7, [r4, #40] ; 0x28
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
16d8: e88c000f stm ip, {r0, r1, r2, r3}
* Create the root node * * NOTE: UNIX root is 755 and owned by root/root (0/0). */ temp_mt_entry->mt_fs_root.node_access = IMFS_create_root_node(); temp_mt_entry->mt_fs_root.handlers = directory_handlers;
16dc: e5846024 str r6, [r4, #36] ; 0x24
temp_mt_entry->pathconf_limits_and_options = IMFS_LIMITS_AND_OPTIONS;
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
16e0: e3a00001 mov r0, #1
16e4: e3a01010 mov r1, #16
16e8: eb0001d8 bl 1e50 <calloc>
if ( !fs_info ) {
16ec: e3500000 cmp r0, #0
16f0: 0a00000c beq 1728 <IMFS_initialize_support+0xc8>
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
16f4: e5952004 ldr r2, [r5, #4]
fs_info->ino_count = 1;
fs_info->memfile_handlers = memfile_handlers;
fs_info->directory_handlers = directory_handlers;
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
16f8: e594101c ldr r1, [r4, #28]
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
fs_info->ino_count = 1;
16fc: e3a03001 mov r3, #1
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
1700: e880000c stm r0, {r2, r3}
fs_info->ino_count = 1; fs_info->memfile_handlers = memfile_handlers; fs_info->directory_handlers = directory_handlers;
1704: e580600c str r6, [r0, #12]
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
fs_info->ino_count = 1;
fs_info->memfile_handlers = memfile_handlers;
1708: e5808008 str r8, [r0, #8]
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
170c: e0822003 add r2, r2, r3
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
if ( !fs_info ) {
free(temp_mt_entry->mt_fs_root.node_access);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
temp_mt_entry->fs_info = fs_info;
1710: e5840034 str r0, [r4, #52] ; 0x34
fs_info->ino_count = 1;
fs_info->memfile_handlers = memfile_handlers;
fs_info->directory_handlers = directory_handlers;
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
1714: e5813038 str r3, [r1, #56] ; 0x38
/*
* Set st_ino for the root to 1.
*/
fs_info->instance = imfs_instance++;
1718: e5852004 str r2, [r5, #4]
jnode = temp_mt_entry->mt_fs_root.node_access;
jnode->st_ino = fs_info->ino_count;
/* Initialize POSIX FIFO/pipe module */
rtems_pipe_initialize();
171c: eb001e56 bl 907c <rtems_pipe_initialize>
1720: e3a00000 mov r0, #0
return 0;
}
1724: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
/*
* Create custom file system data.
*/
fs_info = calloc( 1, sizeof( IMFS_fs_info_t ) );
if ( !fs_info ) {
free(temp_mt_entry->mt_fs_root.node_access);
1728: e594001c ldr r0, [r4, #28] <== NOT EXECUTED
172c: eb00025d bl 20a8 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
1730: eb0032e2 bl e2c0 <__errno> <== NOT EXECUTED
1734: e3a0300c mov r3, #12 <== NOT EXECUTED
1738: e5803000 str r3, [r0] <== NOT EXECUTED
173c: e3e00000 mvn r0, #0 <== NOT EXECUTED
1740: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00001750 <IMFS_link>:
int IMFS_link(
rtems_filesystem_location_info_t *to_loc, /* IN */
rtems_filesystem_location_info_t *parent_loc, /* IN */
const char *token /* IN */
)
{
1750: e92d4070 push {r4, r5, r6, lr}
int i;
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
1754: e5903000 ldr r3, [r0]
int IMFS_link(
rtems_filesystem_location_info_t *to_loc, /* IN */
rtems_filesystem_location_info_t *parent_loc, /* IN */
const char *token /* IN */
)
{
1758: e24dd048 sub sp, sp, #72 ; 0x48
int i;
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
175c: e58d3028 str r3, [sp, #40] ; 0x28
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
1760: e1d333b4 ldrh r3, [r3, #52] ; 0x34
1764: e3530007 cmp r3, #7
int IMFS_link(
rtems_filesystem_location_info_t *to_loc, /* IN */
rtems_filesystem_location_info_t *parent_loc, /* IN */
const char *token /* IN */
)
{
1768: e1a05001 mov r5, r1
176c: e1a06002 mov r6, r2
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
1770: 8a00001e bhi 17f0 <IMFS_link+0xa0>
rtems_set_errno_and_return_minus_one( EMLINK );
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( token, strlen( token ), new_name, &i );
1774: e1a00002 mov r0, r2
1778: eb0036d5 bl f2d4 <strlen>
177c: e28d4004 add r4, sp, #4
1780: e1a01000 mov r1, r0
1784: e1a02004 mov r2, r4
1788: e28d3044 add r3, sp, #68 ; 0x44
178c: e1a00006 mov r0, r6
1790: eb002450 bl a8d8 <IMFS_get_token>
* was ONLY passed a NULL when we created the root node. We * added a new IMFS_create_root_node() so this path no longer * existed. The result was simpler code which should not have * this path. */ new_node = IMFS_create_node(
1794: e3a03ca2 mov r3, #41472 ; 0xa200
1798: e28dc028 add ip, sp, #40 ; 0x28
179c: e1a00005 mov r0, r5
17a0: e1a02004 mov r2, r4
17a4: e2433001 sub r3, r3, #1
17a8: e3a01003 mov r1, #3
17ac: e58dc000 str ip, [sp]
17b0: eb0020ca bl 9ae0 <IMFS_create_node>
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if ( !new_node )
17b4: e3500000 cmp r0, #0
17b8: 0a000011 beq 1804 <IMFS_link+0xb4>
rtems_set_errno_and_return_minus_one( ENOMEM );
/*
* Increment the link count of the node being pointed to.
*/
info.hard_link.link_node->st_nlink++;
17bc: e59d3028 ldr r3, [sp, #40] ; 0x28
17c0: e1d323b4 ldrh r2, [r3, #52] ; 0x34
17c4: e2822001 add r2, r2, #1
17c8: e1c323b4 strh r2, [r3, #52] ; 0x34
IMFS_update_ctime( info.hard_link.link_node );
17cc: e28d003c add r0, sp, #60 ; 0x3c
17d0: e3a01000 mov r1, #0
17d4: eb00025c bl 214c <gettimeofday>
17d8: e59d203c ldr r2, [sp, #60] ; 0x3c
17dc: e59d3028 ldr r3, [sp, #40] ; 0x28
17e0: e5832048 str r2, [r3, #72] ; 0x48
17e4: e3a00000 mov r0, #0
return 0;
}
17e8: e28dd048 add sp, sp, #72 ; 0x48
17ec: e8bd8070 pop {r4, r5, r6, pc}
/*
* Verify this node can be linked to.
*/
info.hard_link.link_node = to_loc->node_access;
if ( info.hard_link.link_node->st_nlink >= LINK_MAX )
rtems_set_errno_and_return_minus_one( EMLINK );
17f0: eb0032b2 bl e2c0 <__errno>
17f4: e3a0301f mov r3, #31
17f8: e5803000 str r3, [r0]
17fc: e3e00000 mvn r0, #0
1800: eafffff8 b 17e8 <IMFS_link+0x98>
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if ( !new_node )
rtems_set_errno_and_return_minus_one( ENOMEM );
1804: eb0032ad bl e2c0 <__errno> <== NOT EXECUTED
1808: e3a0300c mov r3, #12 <== NOT EXECUTED
180c: e5803000 str r3, [r0] <== NOT EXECUTED
1810: e3e00000 mvn r0, #0 <== NOT EXECUTED
1814: eafffff3 b 17e8 <IMFS_link+0x98> <== NOT EXECUTED
0000c980 <IMFS_memfile_addblock>:
)
{
block_p memory;
block_p *block_entry_ptr;
assert( the_jnode );
c980: e2503000 subs r3, r0, #0
MEMFILE_STATIC int IMFS_memfile_addblock(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
c984: e92d4030 push {r4, r5, lr}
block_p memory;
block_p *block_entry_ptr;
assert( the_jnode );
c988: 0a00000f beq c9cc <IMFS_memfile_addblock+0x4c>
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
c98c: e593304c ldr r3, [r3, #76] ; 0x4c
c990: e3530005 cmp r3, #5
c994: 1a000012 bne c9e4 <IMFS_memfile_addblock+0x64>
if ( the_jnode->type != IMFS_MEMORY_FILE )
rtems_set_errno_and_return_minus_one( EIO );
block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
c998: e3a02001 mov r2, #1
c99c: ebfffe99 bl c408 <IMFS_memfile_get_block_pointer>
if ( *block_entry_ptr )
c9a0: e5904000 ldr r4, [r0]
c9a4: e3540000 cmp r4, #0
assert( the_jnode->type == IMFS_MEMORY_FILE );
if ( the_jnode->type != IMFS_MEMORY_FILE )
rtems_set_errno_and_return_minus_one( EIO );
block_entry_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 1 );
c9a8: e1a05000 mov r5, r0
if ( *block_entry_ptr )
c9ac: 13a00000 movne r0, #0
c9b0: 18bd8030 popne {r4, r5, pc}
#if 0
fprintf(stdout, "%d %p", block, block_entry_ptr );
fflush(stdout);
#endif
memory = memfile_alloc_block();
c9b4: ebfffe86 bl c3d4 <memfile_alloc_block>
if ( !memory )
c9b8: e3500000 cmp r0, #0
return 1;
*block_entry_ptr = memory;
c9bc: 15850000 strne r0, [r5]
fprintf(stdout, "%d %p", block, block_entry_ptr );
fflush(stdout);
#endif
memory = memfile_alloc_block();
if ( !memory )
c9c0: 03a00001 moveq r0, #1
return 1;
*block_entry_ptr = memory;
c9c4: 11a00004 movne r0, r4
return 0;
}
c9c8: e8bd8030 pop {r4, r5, pc}
)
{
block_p memory;
block_p *block_entry_ptr;
assert( the_jnode );
c9cc: e3a01f5a mov r1, #360 ; 0x168 <== NOT EXECUTED
c9d0: e2811001 add r1, r1, #1 <== NOT EXECUTED
c9d4: e59f0020 ldr r0, [pc, #32] ; c9fc <IMFS_memfile_addblock+0x7c><== NOT EXECUTED
c9d8: e59f2020 ldr r2, [pc, #32] ; ca00 <IMFS_memfile_addblock+0x80><== NOT EXECUTED
c9dc: e59f3020 ldr r3, [pc, #32] ; ca04 <IMFS_memfile_addblock+0x84><== NOT EXECUTED
c9e0: ebfff85b bl ab54 <__assert_func> <== NOT EXECUTED
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
c9e4: e3a01f5b mov r1, #364 ; 0x16c <== NOT EXECUTED
c9e8: e2811001 add r1, r1, #1 <== NOT EXECUTED
c9ec: e59f0008 ldr r0, [pc, #8] ; c9fc <IMFS_memfile_addblock+0x7c><== NOT EXECUTED
c9f0: e59f2008 ldr r2, [pc, #8] ; ca00 <IMFS_memfile_addblock+0x80><== NOT EXECUTED
c9f4: e59f300c ldr r3, [pc, #12] ; ca08 <IMFS_memfile_addblock+0x88><== NOT EXECUTED
c9f8: ebfff855 bl ab54 <__assert_func> <== NOT EXECUTED
0000ca0c <IMFS_memfile_extend>:
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
ca0c: e92d4df0 push {r4, r5, r6, r7, r8, sl, fp, lr}
/*
* Perform internal consistency checks
*/
assert( the_jnode );
ca10: e2504000 subs r4, r0, #0
MEMFILE_STATIC int IMFS_memfile_extend(
IMFS_jnode_t *the_jnode,
off_t new_length
)
{
ca14: e24dd004 sub sp, sp, #4
ca18: e1a08001 mov r8, r1
ca1c: e1a06002 mov r6, r2
/*
* Perform internal consistency checks
*/
assert( the_jnode );
ca20: 0a00004f beq cb64 <IMFS_memfile_extend+0x158>
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
ca24: e594304c ldr r3, [r4, #76] ; 0x4c
ca28: e3530005 cmp r3, #5
ca2c: 1a000046 bne cb4c <IMFS_memfile_extend+0x140>
if ( the_jnode->type != IMFS_MEMORY_FILE )
rtems_set_errno_and_return_minus_one( EIO );
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
ca30: e59f3144 ldr r3, [pc, #324] ; cb7c <IMFS_memfile_extend+0x170>
ca34: e593b000 ldr fp, [r3]
ca38: e1a0312b lsr r3, fp, #2
ca3c: e0213393 mla r1, r3, r3, r3
ca40: e0223391 mla r2, r1, r3, r3
ca44: e3a03000 mov r3, #0
ca48: e1530006 cmp r3, r6
ca4c: e2423001 sub r3, r2, #1
ca50: e002039b mul r2, fp, r3
ca54: da000034 ble cb2c <IMFS_memfile_extend+0x120>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( new_length <= the_jnode->info.file.size )
ca58: e5947054 ldr r7, [r4, #84] ; 0x54
ca5c: e1560007 cmp r6, r7
ca60: e594a050 ldr sl, [r4, #80] ; 0x50
ca64: da000027 ble cb08 <IMFS_memfile_extend+0xfc>
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
ca68: e1a0cfcb asr ip, fp, #31
ca6c: e1a0300c mov r3, ip
ca70: e1a0200b mov r2, fp
ca74: e1a00008 mov r0, r8
ca78: e1a01006 mov r1, r6
ca7c: e58dc000 str ip, [sp]
ca80: eb002e89 bl 184ac <__divdi3>
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
ca84: e59dc000 ldr ip, [sp]
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
ca88: e1a05000 mov r5, r0
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
ca8c: e1a01007 mov r1, r7
ca90: e1a0000a mov r0, sl
ca94: e1a0200b mov r2, fp
ca98: e1a0300c mov r3, ip
ca9c: eb002e82 bl 184ac <__divdi3>
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
caa0: e1550000 cmp r5, r0
/*
* Calculate the number of range of blocks to allocate
*/
new_blocks = new_length / IMFS_MEMFILE_BYTES_PER_BLOCK;
old_blocks = the_jnode->info.file.size / IMFS_MEMFILE_BYTES_PER_BLOCK;
caa4: e1a0a000 mov sl, r0
/*
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
caa8: 3a00001b bcc cb1c <IMFS_memfile_extend+0x110>
caac: e1a07000 mov r7, r0
cab0: ea000002 b cac0 <IMFS_memfile_extend+0xb4>
cab4: e2877001 add r7, r7, #1
cab8: e1550007 cmp r5, r7
cabc: 3a000016 bcc cb1c <IMFS_memfile_extend+0x110>
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
cac0: e1a00004 mov r0, r4
cac4: e1a01007 mov r1, r7
cac8: ebffffac bl c980 <IMFS_memfile_addblock>
cacc: e3500000 cmp r0, #0
cad0: 0afffff7 beq cab4 <IMFS_memfile_extend+0xa8>
cad4: ea000003 b cae8 <IMFS_memfile_extend+0xdc> <== NOT EXECUTED
for ( ; block>=old_blocks ; block-- ) {
IMFS_memfile_remove_block( the_jnode, block );
cad8: e1a01007 mov r1, r7 <== NOT EXECUTED
cadc: e1a00004 mov r0, r4 <== NOT EXECUTED
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
for ( ; block>=old_blocks ; block-- ) {
cae0: e2477001 sub r7, r7, #1 <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
cae4: ebfffef5 bl c6c0 <IMFS_memfile_remove_block> <== NOT EXECUTED
* Now allocate each of those blocks.
*/
for ( block=old_blocks ; block<=new_blocks ; block++ ) {
if ( IMFS_memfile_addblock( the_jnode, block ) ) {
for ( ; block>=old_blocks ; block-- ) {
cae8: e15a0007 cmp sl, r7 <== NOT EXECUTED
caec: 9afffff9 bls cad8 <IMFS_memfile_extend+0xcc> <== NOT EXECUTED
IMFS_memfile_remove_block( the_jnode, block );
}
rtems_set_errno_and_return_minus_one( ENOSPC );
caf0: eb0005f2 bl e2c0 <__errno> <== NOT EXECUTED
caf4: e3a0301c mov r3, #28 <== NOT EXECUTED
caf8: e5803000 str r3, [r0] <== NOT EXECUTED
cafc: e3e00000 mvn r0, #0 <== NOT EXECUTED
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
return 0;
}
cb00: e28dd004 add sp, sp, #4
cb04: e8bd8df0 pop {r4, r5, r6, r7, r8, sl, fp, pc}
rtems_set_errno_and_return_minus_one( EIO );
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( new_length <= the_jnode->info.file.size )
cb08: 1a000001 bne cb14 <IMFS_memfile_extend+0x108>
cb0c: e158000a cmp r8, sl
cb10: 8affffd4 bhi ca68 <IMFS_memfile_extend+0x5c>
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
cb14: e3a00000 mov r0, #0
return 0;
cb18: eafffff8 b cb00 <IMFS_memfile_extend+0xf4>
/*
* Set the new length of the file.
*/
the_jnode->info.file.size = new_length;
cb1c: e5846054 str r6, [r4, #84] ; 0x54
cb20: e5848050 str r8, [r4, #80] ; 0x50
cb24: e3a00000 mov r0, #0
cb28: eafffff4 b cb00 <IMFS_memfile_extend+0xf4>
assert( the_jnode->type == IMFS_MEMORY_FILE );
if ( the_jnode->type != IMFS_MEMORY_FILE )
rtems_set_errno_and_return_minus_one( EIO );
if ( new_length >= IMFS_MEMFILE_MAXIMUM_SIZE )
cb2c: 1a000001 bne cb38 <IMFS_memfile_extend+0x12c>
cb30: e1520008 cmp r2, r8
cb34: 8affffc7 bhi ca58 <IMFS_memfile_extend+0x4c>
rtems_set_errno_and_return_minus_one( EINVAL );
cb38: eb0005e0 bl e2c0 <__errno> <== NOT EXECUTED
cb3c: e3a03016 mov r3, #22 <== NOT EXECUTED
cb40: e5803000 str r3, [r0] <== NOT EXECUTED
cb44: e3e00000 mvn r0, #0 <== NOT EXECUTED
cb48: eaffffec b cb00 <IMFS_memfile_extend+0xf4> <== NOT EXECUTED
assert( the_jnode );
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
cb4c: e3a01f4d mov r1, #308 ; 0x134 <== NOT EXECUTED
cb50: e2811001 add r1, r1, #1 <== NOT EXECUTED
cb54: e59f0024 ldr r0, [pc, #36] ; cb80 <IMFS_memfile_extend+0x174><== NOT EXECUTED
cb58: e59f2024 ldr r2, [pc, #36] ; cb84 <IMFS_memfile_extend+0x178><== NOT EXECUTED
cb5c: e59f3024 ldr r3, [pc, #36] ; cb88 <IMFS_memfile_extend+0x17c><== NOT EXECUTED
cb60: ebfff7fb bl ab54 <__assert_func> <== NOT EXECUTED
/*
* Perform internal consistency checks
*/
assert( the_jnode );
cb64: e3a01e13 mov r1, #304 ; 0x130 <== NOT EXECUTED
cb68: e2811001 add r1, r1, #1 <== NOT EXECUTED
cb6c: e59f000c ldr r0, [pc, #12] ; cb80 <IMFS_memfile_extend+0x174><== NOT EXECUTED
cb70: e59f200c ldr r2, [pc, #12] ; cb84 <IMFS_memfile_extend+0x178><== NOT EXECUTED
cb74: e59f3010 ldr r3, [pc, #16] ; cb8c <IMFS_memfile_extend+0x180><== NOT EXECUTED
cb78: ebfff7f5 bl ab54 <__assert_func> <== NOT EXECUTED
0000c408 <IMFS_memfile_get_block_pointer>:
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
c408: e92d41f0 push {r4, r5, r6, r7, r8, lr}
/*
* Perform internal consistency checks
*/
assert( the_jnode );
c40c: e2504000 subs r4, r0, #0
#endif
IMFS_jnode_t *the_jnode,
unsigned int block,
int malloc_it
)
{
c410: e24dd004 sub sp, sp, #4
/*
* Perform internal consistency checks
*/
assert( the_jnode );
c414: 0a000073 beq c5e8 <IMFS_memfile_get_block_pointer+0x1e0>
if ( !the_jnode )
return NULL;
assert( the_jnode->type == IMFS_MEMORY_FILE );
c418: e594304c ldr r3, [r4, #76] ; 0x4c
c41c: e3530005 cmp r3, #5
c420: 1a00006b bne c5d4 <IMFS_memfile_get_block_pointer+0x1cc>
/*
* Is the block number in the simple indirect portion?
*/
if ( my_block <= LAST_INDIRECT ) {
c424: e59f31f8 ldr r3, [pc, #504] ; c624 <IMFS_memfile_get_block_pointer+0x21c>
c428: e5935000 ldr r5, [r3]
c42c: e1a05125 lsr r5, r5, #2
c430: e2453001 sub r3, r5, #1
c434: e1510003 cmp r1, r3
c438: 9a000019 bls c4a4 <IMFS_memfile_get_block_pointer+0x9c>
/*
* Is the block number in the doubly indirect portion?
*/
if ( my_block <= LAST_DOUBLY_INDIRECT ) {
c43c: e0265595 mla r6, r5, r5, r5 <== NOT EXECUTED
c440: e2463001 sub r3, r6, #1 <== NOT EXECUTED
c444: e1510003 cmp r1, r3 <== NOT EXECUTED
c448: 8a000025 bhi c4e4 <IMFS_memfile_get_block_pointer+0xdc> <== NOT EXECUTED
#if 0
fprintf(stdout, "(d %d) ", block );
fflush(stdout);
#endif
my_block -= FIRST_DOUBLY_INDIRECT;
c44c: e0656001 rsb r6, r5, r1 <== NOT EXECUTED
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c450: e1a00006 mov r0, r6 <== NOT EXECUTED
c454: e1a01005 mov r1, r5 <== NOT EXECUTED
c458: e58d2000 str r2, [sp] <== NOT EXECUTED
c45c: eb002d65 bl 179f8 <__umodsi3> <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c460: e1a01005 mov r1, r5 <== NOT EXECUTED
fflush(stdout);
#endif
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c464: e1a07000 mov r7, r0 <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c468: e1a00006 mov r0, r6 <== NOT EXECUTED
c46c: eb002d1d bl 178e8 <__aeabi_uidiv> <== NOT EXECUTED
p = info->doubly_indirect;
if ( malloc_it ) {
c470: e59d2000 ldr r2, [sp] <== NOT EXECUTED
c474: e3520000 cmp r2, #0 <== NOT EXECUTED
#endif
my_block -= FIRST_DOUBLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c478: e1a05000 mov r5, r0 <== NOT EXECUTED
p = info->doubly_indirect;
c47c: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
if ( malloc_it ) {
c480: 0a000047 beq c5a4 <IMFS_memfile_get_block_pointer+0x19c> <== NOT EXECUTED
if ( !p ) {
c484: e3530000 cmp r3, #0 <== NOT EXECUTED
c488: 0a00004c beq c5c0 <IMFS_memfile_get_block_pointer+0x1b8> <== NOT EXECUTED
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
c48c: e7930105 ldr r0, [r3, r5, lsl #2] <== NOT EXECUTED
if ( !p1 ) {
c490: e3500000 cmp r0, #0 <== NOT EXECUTED
if ( !p )
return 0;
info->doubly_indirect = p;
}
p1 = (block_p *)p[ doubly ];
c494: e0835105 add r5, r3, r5, lsl #2 <== NOT EXECUTED
if ( !p1 ) {
c498: 0a000034 beq c570 <IMFS_memfile_get_block_pointer+0x168> <== NOT EXECUTED
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
c49c: e0800107 add r0, r0, r7, lsl #2 <== NOT EXECUTED
c4a0: ea000005 b c4bc <IMFS_memfile_get_block_pointer+0xb4> <== NOT EXECUTED
fprintf(stdout, "(s %d) ", block );
fflush(stdout);
#endif
p = info->indirect;
if ( malloc_it ) {
c4a4: e3520000 cmp r2, #0
if ( my_block <= LAST_INDIRECT ) {
#if 0
fprintf(stdout, "(s %d) ", block );
fflush(stdout);
#endif
p = info->indirect;
c4a8: e5940058 ldr r0, [r4, #88] ; 0x58
if ( malloc_it ) {
c4ac: 0a000035 beq c588 <IMFS_memfile_get_block_pointer+0x180>
if ( !p ) {
c4b0: e3500000 cmp r0, #0
c4b4: 0a000002 beq c4c4 <IMFS_memfile_get_block_pointer+0xbc>
}
if ( !p )
return 0;
return &info->indirect[ my_block ];
c4b8: e0800101 add r0, r0, r1, lsl #2
/*
* This means the requested block number is out of range.
*/
return 0;
}
c4bc: e28dd004 add sp, sp, #4
c4c0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
p = info->indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
c4c4: e58d1000 str r1, [sp]
c4c8: ebffffc1 bl c3d4 <memfile_alloc_block>
if ( !p )
c4cc: e3500000 cmp r0, #0
c4d0: e59d1000 ldr r1, [sp]
return 0;
info->indirect = p;
c4d4: 15840058 strne r0, [r4, #88] ; 0x58
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
if ( !p )
c4d8: 1afffff6 bne c4b8 <IMFS_memfile_get_block_pointer+0xb0>
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
c4dc: e3a00000 mov r0, #0 <== NOT EXECUTED
c4e0: eafffff5 b c4bc <IMFS_memfile_get_block_pointer+0xb4> <== NOT EXECUTED
#endif
/*
* Is the block number in the triply indirect portion?
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
c4e4: e0235596 mla r3, r6, r5, r5 <== NOT EXECUTED
c4e8: e2433001 sub r3, r3, #1 <== NOT EXECUTED
c4ec: e1510003 cmp r1, r3 <== NOT EXECUTED
c4f0: 8afffff9 bhi c4dc <IMFS_memfile_get_block_pointer+0xd4> <== NOT EXECUTED
my_block -= FIRST_TRIPLY_INDIRECT;
c4f4: e0666001 rsb r6, r6, r1 <== NOT EXECUTED
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c4f8: e1a00006 mov r0, r6 <== NOT EXECUTED
c4fc: e1a01005 mov r1, r5 <== NOT EXECUTED
c500: e58d2000 str r2, [sp] <== NOT EXECUTED
c504: eb002d3b bl 179f8 <__umodsi3> <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c508: e1a01005 mov r1, r5 <== NOT EXECUTED
*/
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
c50c: e1a07000 mov r7, r0 <== NOT EXECUTED
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c510: e1a00006 mov r0, r6 <== NOT EXECUTED
c514: eb002cf3 bl 178e8 <__aeabi_uidiv> <== NOT EXECUTED
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
c518: e1a01005 mov r1, r5 <== NOT EXECUTED
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
c51c: e1a08000 mov r8, r0 <== NOT EXECUTED
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
c520: eb002cf0 bl 178e8 <__aeabi_uidiv> <== NOT EXECUTED
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
c524: e1a01005 mov r1, r5 <== NOT EXECUTED
if ( my_block <= LAST_TRIPLY_INDIRECT ) {
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
c528: e1a06000 mov r6, r0 <== NOT EXECUTED
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
c52c: e1a00008 mov r0, r8 <== NOT EXECUTED
c530: eb002d30 bl 179f8 <__umodsi3> <== NOT EXECUTED
p = info->triply_indirect;
if ( malloc_it ) {
c534: e59d2000 ldr r2, [sp] <== NOT EXECUTED
c538: e3520000 cmp r2, #0 <== NOT EXECUTED
my_block -= FIRST_TRIPLY_INDIRECT;
singly = my_block % IMFS_MEMFILE_BLOCK_SLOTS;
doubly = my_block / IMFS_MEMFILE_BLOCK_SLOTS;
triply = doubly / IMFS_MEMFILE_BLOCK_SLOTS;
doubly %= IMFS_MEMFILE_BLOCK_SLOTS;
c53c: e1a05000 mov r5, r0 <== NOT EXECUTED
p = info->triply_indirect;
c540: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
if ( malloc_it ) {
c544: 0a000013 beq c598 <IMFS_memfile_get_block_pointer+0x190> <== NOT EXECUTED
if ( !p ) {
c548: e3530000 cmp r3, #0 <== NOT EXECUTED
c54c: 0a00002f beq c610 <IMFS_memfile_get_block_pointer+0x208> <== NOT EXECUTED
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
c550: e7932106 ldr r2, [r3, r6, lsl #2] <== NOT EXECUTED
if ( !p1 ) {
c554: e3520000 cmp r2, #0 <== NOT EXECUTED
if ( !p )
return 0;
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
c558: e0836106 add r6, r3, r6, lsl #2 <== NOT EXECUTED
if ( !p1 ) {
c55c: 0a000026 beq c5fc <IMFS_memfile_get_block_pointer+0x1f4> <== NOT EXECUTED
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
c560: e7920105 ldr r0, [r2, r5, lsl #2] <== NOT EXECUTED
if ( !p2 ) {
c564: e3500000 cmp r0, #0 <== NOT EXECUTED
if ( !p1 )
return 0;
p[ triply ] = (block_p) p1;
}
p2 = (block_p *)p1[ doubly ];
c568: e0825105 add r5, r2, r5, lsl #2 <== NOT EXECUTED
if ( !p2 ) {
c56c: 1affffca bne c49c <IMFS_memfile_get_block_pointer+0x94> <== NOT EXECUTED
p2 = memfile_alloc_block();
c570: ebffff97 bl c3d4 <memfile_alloc_block> <== NOT EXECUTED
if ( !p2 )
c574: e3500000 cmp r0, #0 <== NOT EXECUTED
return 0;
p1[ doubly ] = (block_p) p2;
c578: 15850000 strne r0, [r5] <== NOT EXECUTED
}
p2 = (block_p *)p1[ doubly ];
if ( !p2 ) {
p2 = memfile_alloc_block();
if ( !p2 )
c57c: 0affffd6 beq c4dc <IMFS_memfile_get_block_pointer+0xd4> <== NOT EXECUTED
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
c580: e0800107 add r0, r0, r7, lsl #2 <== NOT EXECUTED
c584: eaffffcc b c4bc <IMFS_memfile_get_block_pointer+0xb4> <== NOT EXECUTED
info->indirect = p;
}
return &info->indirect[ my_block ];
}
if ( !p )
c588: e3500000 cmp r0, #0
c58c: 1affffc9 bne c4b8 <IMFS_memfile_get_block_pointer+0xb0>
p2 = (block_p *)p1[ doubly ];
if ( !p2 )
return 0;
return (block_p *)&p2[ singly ];
c590: e3a00000 mov r0, #0 <== NOT EXECUTED
c594: eaffffc8 b c4bc <IMFS_memfile_get_block_pointer+0xb4> <== NOT EXECUTED
p1[ doubly ] = (block_p) p2;
}
return (block_p *)&p2[ singly ];
}
if ( !p )
c598: e3530000 cmp r3, #0 <== NOT EXECUTED
c59c: 0affffce beq c4dc <IMFS_memfile_get_block_pointer+0xd4> <== NOT EXECUTED
#if 0
fprintf(stdout, "(t %d %d %d %d %d) ", block, my_block, triply, doubly, singly );
fflush(stdout);
#endif
p1 = (block_p *) p[ triply ];
c5a0: e7933106 ldr r3, [r3, r6, lsl #2] <== NOT EXECUTED
if ( !p1 )
c5a4: e3530000 cmp r3, #0 <== NOT EXECUTED
c5a8: 0affffcb beq c4dc <IMFS_memfile_get_block_pointer+0xd4> <== NOT EXECUTED
return 0;
p2 = (block_p *)p1[ doubly ];
c5ac: e7930105 ldr r0, [r3, r5, lsl #2] <== NOT EXECUTED
if ( !p2 )
c5b0: e3500000 cmp r0, #0 <== NOT EXECUTED
c5b4: 0affffc8 beq c4dc <IMFS_memfile_get_block_pointer+0xd4> <== NOT EXECUTED
return 0;
return (block_p *)&p2[ singly ];
c5b8: e0800107 add r0, r0, r7, lsl #2 <== NOT EXECUTED
c5bc: eaffffbe b c4bc <IMFS_memfile_get_block_pointer+0xb4> <== NOT EXECUTED
p = info->doubly_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
c5c0: ebffff83 bl c3d4 <memfile_alloc_block> <== NOT EXECUTED
if ( !p )
c5c4: e2503000 subs r3, r0, #0 <== NOT EXECUTED
c5c8: 0affffc3 beq c4dc <IMFS_memfile_get_block_pointer+0xd4> <== NOT EXECUTED
return 0;
info->doubly_indirect = p;
c5cc: e584305c str r3, [r4, #92] ; 0x5c <== NOT EXECUTED
c5d0: eaffffad b c48c <IMFS_memfile_get_block_pointer+0x84> <== NOT EXECUTED
assert( the_jnode );
if ( !the_jnode )
return NULL;
assert( the_jnode->type == IMFS_MEMORY_FILE );
c5d4: e59f004c ldr r0, [pc, #76] ; c628 <IMFS_memfile_get_block_pointer+0x220><== NOT EXECUTED
c5d8: e3a01fe3 mov r1, #908 ; 0x38c <== NOT EXECUTED
c5dc: e59f2048 ldr r2, [pc, #72] ; c62c <IMFS_memfile_get_block_pointer+0x224><== NOT EXECUTED
c5e0: e59f3048 ldr r3, [pc, #72] ; c630 <IMFS_memfile_get_block_pointer+0x228><== NOT EXECUTED
c5e4: ebfff95a bl ab54 <__assert_func> <== NOT EXECUTED
/*
* Perform internal consistency checks
*/
assert( the_jnode );
c5e8: e59f0038 ldr r0, [pc, #56] ; c628 <IMFS_memfile_get_block_pointer+0x220><== NOT EXECUTED
c5ec: e3a01fe2 mov r1, #904 ; 0x388 <== NOT EXECUTED
c5f0: e59f2034 ldr r2, [pc, #52] ; c62c <IMFS_memfile_get_block_pointer+0x224><== NOT EXECUTED
c5f4: e59f3038 ldr r3, [pc, #56] ; c634 <IMFS_memfile_get_block_pointer+0x22c><== NOT EXECUTED
c5f8: ebfff955 bl ab54 <__assert_func> <== NOT EXECUTED
info->triply_indirect = p;
}
p1 = (block_p *) p[ triply ];
if ( !p1 ) {
p1 = memfile_alloc_block();
c5fc: ebffff74 bl c3d4 <memfile_alloc_block> <== NOT EXECUTED
if ( !p1 )
c600: e2502000 subs r2, r0, #0 <== NOT EXECUTED
c604: 0affffb4 beq c4dc <IMFS_memfile_get_block_pointer+0xd4> <== NOT EXECUTED
return 0;
p[ triply ] = (block_p) p1;
c608: e5862000 str r2, [r6] <== NOT EXECUTED
c60c: eaffffd3 b c560 <IMFS_memfile_get_block_pointer+0x158> <== NOT EXECUTED
p = info->triply_indirect;
if ( malloc_it ) {
if ( !p ) {
p = memfile_alloc_block();
c610: ebffff6f bl c3d4 <memfile_alloc_block> <== NOT EXECUTED
if ( !p )
c614: e2503000 subs r3, r0, #0 <== NOT EXECUTED
c618: 0affffaf beq c4dc <IMFS_memfile_get_block_pointer+0xd4> <== NOT EXECUTED
return 0;
info->triply_indirect = p;
c61c: e5843060 str r3, [r4, #96] ; 0x60 <== NOT EXECUTED
c620: eaffffca b c550 <IMFS_memfile_get_block_pointer+0x148> <== NOT EXECUTED
0000d028 <IMFS_memfile_read>:
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
d028: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
/*
* Perform internal consistency checks
*/
assert( the_jnode );
d02c: e2509000 subs r9, r0, #0
IMFS_jnode_t *the_jnode,
off_t start,
unsigned char *destination,
unsigned int length
)
{
d030: e24dd014 sub sp, sp, #20
d034: e1a08003 mov r8, r3
d038: e1a0a001 mov sl, r1
d03c: e1a0b002 mov fp, r2
d040: e59d5038 ldr r5, [sp, #56] ; 0x38
/*
* Perform internal consistency checks
*/
assert( the_jnode );
d044: 0a000089 beq d270 <IMFS_memfile_read+0x248>
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE ||
d048: e599304c ldr r3, [r9, #76] ; 0x4c
d04c: e2432005 sub r2, r3, #5
d050: e3520001 cmp r2, #1
d054: 8a000096 bhi d2b4 <IMFS_memfile_read+0x28c>
/*
* Error checks on arguments
*/
assert( dest );
d058: e3580000 cmp r8, #0
d05c: 0a00008e beq d29c <IMFS_memfile_read+0x274>
/*
* If there is nothing to read, then quick exit.
*/
my_length = length;
if ( !my_length )
d060: e3550000 cmp r5, #0
d064: 0a000076 beq d244 <IMFS_memfile_read+0x21c>
/*
* Linear files (as created from a tar file are easier to handle
* than block files).
*/
if (the_jnode->type == IMFS_LINEAR_FILE) {
d068: e3530006 cmp r3, #6
d06c: 0a00005a beq d1dc <IMFS_memfile_read+0x1b4>
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
d070: e5993054 ldr r3, [r9, #84] ; 0x54
d074: e3a02000 mov r2, #0
d078: e1520003 cmp r2, r3
/*
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
d07c: e1a03001 mov r3, r1
if ( last_byte > the_jnode->info.file.size )
d080: e5992050 ldr r2, [r9, #80] ; 0x50
d084: e0851001 add r1, r5, r1
d088: da00004f ble d1cc <IMFS_memfile_read+0x1a4>
my_length = the_jnode->info.file.size - start;
d08c: e0635002 rsb r5, r3, r2
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
d090: e59f624c ldr r6, [pc, #588] ; d2e4 <IMFS_memfile_read+0x2bc>
d094: e5964000 ldr r4, [r6]
d098: e1a0000a mov r0, sl
d09c: e1a02004 mov r2, r4
d0a0: e1a03fc2 asr r3, r2, #31
d0a4: e1a0100b mov r1, fp
d0a8: e98d000c stmib sp, {r2, r3}
d0ac: eb002e28 bl 18954 <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
d0b0: e1a0100b mov r1, fp
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
d0b4: e1a0c000 mov ip, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
d0b8: e99d000c ldmib sp, {r2, r3}
d0bc: e1a0000a mov r0, sl
d0c0: e58dc000 str ip, [sp]
d0c4: eb002cf8 bl 184ac <__divdi3>
if ( start_offset ) {
d0c8: e59dc000 ldr ip, [sp]
d0cc: e35c0000 cmp ip, #0
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
d0d0: e1a07000 mov r7, r0
if ( start_offset ) {
d0d4: 01a0a00c moveq sl, ip
d0d8: 0a000013 beq d12c <IMFS_memfile_read+0x104>
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
d0dc: e1a00009 mov r0, r9
d0e0: e1a01007 mov r1, r7
d0e4: e3a02000 mov r2, #0
d0e8: e58dc000 str ip, [sp]
d0ec: ebfffcc5 bl c408 <IMFS_memfile_get_block_pointer>
assert( block_ptr );
d0f0: e3500000 cmp r0, #0
d0f4: e59dc000 ldr ip, [sp]
d0f8: 0a000073 beq d2cc <IMFS_memfile_read+0x2a4>
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
d0fc: e06ca004 rsb sl, ip, r4
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
assert( block_ptr );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
d100: e5901000 ldr r1, [r0]
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
d104: e155000a cmp r5, sl
d108: 31a0a005 movcc sl, r5
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
assert( block_ptr );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
d10c: e1a00008 mov r0, r8
d110: e081100c add r1, r1, ip
d114: e1a0200a mov r2, sl
d118: eb000676 bl eaf8 <memcpy>
dest += to_copy;
block++;
my_length -= to_copy;
d11c: e5964000 ldr r4, [r6]
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
assert( block_ptr );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ start_offset ], to_copy );
dest += to_copy;
d120: e088800a add r8, r8, sl
block++;
d124: e2877001 add r7, r7, #1
my_length -= to_copy;
d128: e06a5005 rsb r5, sl, r5
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
d12c: e1550004 cmp r5, r4
d130: 3a000010 bcc d178 <IMFS_memfile_read+0x150>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
d134: e1a00009 mov r0, r9
d138: e1a01007 mov r1, r7
d13c: e3a02000 mov r2, #0
d140: ebfffcb0 bl c408 <IMFS_memfile_get_block_pointer>
assert( block_ptr );
d144: e3500000 cmp r0, #0
d148: 0a000042 beq d258 <IMFS_memfile_read+0x230>
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
d14c: e5901000 ldr r1, [r0]
d150: e1a02004 mov r2, r4
d154: e1a00008 mov r0, r8
d158: eb000666 bl eaf8 <memcpy>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
d15c: e5963000 ldr r3, [r6]
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
dest += to_copy;
block++;
my_length -= to_copy;
d160: e0645005 rsb r5, r4, r5
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
d164: e1530005 cmp r3, r5
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
assert( block_ptr );
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], to_copy );
dest += to_copy;
d168: e0888004 add r8, r8, r4
block++;
d16c: e2877001 add r7, r7, #1
my_length -= to_copy;
copied += to_copy;
d170: e08aa004 add sl, sl, r4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
d174: 9affffee bls d134 <IMFS_memfile_read+0x10c>
* Phase 3: possibly the first part of one block
*/
assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
d178: e3550000 cmp r5, #0
d17c: 0a00000a beq d1ac <IMFS_memfile_read+0x184>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
d180: e1a01007 mov r1, r7
d184: e1a00009 mov r0, r9
d188: e3a02000 mov r2, #0
d18c: ebfffc9d bl c408 <IMFS_memfile_get_block_pointer>
assert( block_ptr );
d190: e2503000 subs r3, r0, #0
d194: 0a00003a beq d284 <IMFS_memfile_read+0x25c>
if ( !block_ptr )
return copied;
memcpy( dest, &(*block_ptr)[ 0 ], my_length );
d198: e1a00008 mov r0, r8
d19c: e5931000 ldr r1, [r3]
d1a0: e1a02005 mov r2, r5
d1a4: eb000653 bl eaf8 <memcpy>
copied += my_length;
d1a8: e08aa005 add sl, sl, r5
}
IMFS_update_atime( the_jnode );
d1ac: e28d000c add r0, sp, #12
d1b0: e3a01000 mov r1, #0
d1b4: ebffd3e4 bl 214c <gettimeofday>
d1b8: e59d300c ldr r3, [sp, #12]
d1bc: e5893040 str r3, [r9, #64] ; 0x40
return copied;
d1c0: e1a0000a mov r0, sl
}
d1c4: e28dd014 add sp, sp, #20
d1c8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* If the last byte we are supposed to read is past the end of this
* in memory file, then shorten the length to read.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size )
d1cc: 1affffaf bne d090 <IMFS_memfile_read+0x68>
d1d0: e1510002 cmp r1, r2
d1d4: 9affffad bls d090 <IMFS_memfile_read+0x68>
d1d8: eaffffab b d08c <IMFS_memfile_read+0x64>
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
d1dc: e2894050 add r4, r9, #80 ; 0x50 <== NOT EXECUTED
d1e0: e8940018 ldm r4, {r3, r4} <== NOT EXECUTED
d1e4: e1a00003 mov r0, r3 <== NOT EXECUTED
d1e8: e1a01004 mov r1, r4 <== NOT EXECUTED
d1ec: e3a02000 mov r2, #0 <== NOT EXECUTED
d1f0: e050000a subs r0, r0, sl <== NOT EXECUTED
d1f4: e0c1100b sbc r1, r1, fp <== NOT EXECUTED
d1f8: e1520001 cmp r2, r1 <== NOT EXECUTED
* than block files).
*/
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
d1fc: e5992058 ldr r2, [r9, #88] ; 0x58 <== NOT EXECUTED
if (my_length > (the_jnode->info.linearfile.size - start))
d200: da00000b ble d234 <IMFS_memfile_read+0x20c> <== NOT EXECUTED
my_length = the_jnode->info.linearfile.size - start;
d204: e06a5003 rsb r5, sl, r3 <== NOT EXECUTED
memcpy(dest, &file_ptr[start], my_length);
d208: e082100a add r1, r2, sl <== NOT EXECUTED
d20c: e1a00008 mov r0, r8 <== NOT EXECUTED
d210: e1a02005 mov r2, r5 <== NOT EXECUTED
d214: eb000637 bl eaf8 <memcpy> <== NOT EXECUTED
IMFS_update_atime( the_jnode );
d218: e28d000c add r0, sp, #12 <== NOT EXECUTED
d21c: e3a01000 mov r1, #0 <== NOT EXECUTED
d220: ebffd3c9 bl 214c <gettimeofday> <== NOT EXECUTED
d224: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
return my_length;
d228: e1a00005 mov r0, r5 <== NOT EXECUTED
if (my_length > (the_jnode->info.linearfile.size - start))
my_length = the_jnode->info.linearfile.size - start;
memcpy(dest, &file_ptr[start], my_length);
IMFS_update_atime( the_jnode );
d22c: e5893040 str r3, [r9, #64] ; 0x40 <== NOT EXECUTED
return my_length;
d230: eaffffe3 b d1c4 <IMFS_memfile_read+0x19c> <== NOT EXECUTED
if (the_jnode->type == IMFS_LINEAR_FILE) {
unsigned char *file_ptr;
file_ptr = (unsigned char *)the_jnode->info.linearfile.direct;
if (my_length > (the_jnode->info.linearfile.size - start))
d234: 1afffff3 bne d208 <IMFS_memfile_read+0x1e0> <== NOT EXECUTED
d238: e1550000 cmp r5, r0 <== NOT EXECUTED
d23c: 8afffff0 bhi d204 <IMFS_memfile_read+0x1dc> <== NOT EXECUTED
d240: eafffff0 b d208 <IMFS_memfile_read+0x1e0> <== NOT EXECUTED
* If there is nothing to read, then quick exit.
*/
my_length = length;
if ( !my_length )
rtems_set_errno_and_return_minus_one( EINVAL );
d244: eb00041d bl e2c0 <__errno> <== NOT EXECUTED
d248: e3a03016 mov r3, #22 <== NOT EXECUTED
d24c: e5803000 str r3, [r0] <== NOT EXECUTED
d250: e3e00000 mvn r0, #0 <== NOT EXECUTED
d254: eaffffda b d1c4 <IMFS_memfile_read+0x19c> <== NOT EXECUTED
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
assert( block_ptr );
d258: e3a01fa9 mov r1, #676 ; 0x2a4 <== NOT EXECUTED
d25c: e2811003 add r1, r1, #3 <== NOT EXECUTED
d260: e59f0080 ldr r0, [pc, #128] ; d2e8 <IMFS_memfile_read+0x2c0><== NOT EXECUTED
d264: e59f2080 ldr r2, [pc, #128] ; d2ec <IMFS_memfile_read+0x2c4><== NOT EXECUTED
d268: e59f3080 ldr r3, [pc, #128] ; d2f0 <IMFS_memfile_read+0x2c8><== NOT EXECUTED
d26c: ebfff638 bl ab54 <__assert_func> <== NOT EXECUTED
/*
* Perform internal consistency checks
*/
assert( the_jnode );
d270: e59f0070 ldr r0, [pc, #112] ; d2e8 <IMFS_memfile_read+0x2c0><== NOT EXECUTED
d274: e3a01f93 mov r1, #588 ; 0x24c <== NOT EXECUTED
d278: e59f206c ldr r2, [pc, #108] ; d2ec <IMFS_memfile_read+0x2c4><== NOT EXECUTED
d27c: e59f3070 ldr r3, [pc, #112] ; d2f4 <IMFS_memfile_read+0x2cc><== NOT EXECUTED
d280: ebfff633 bl ab54 <__assert_func> <== NOT EXECUTED
assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
assert( block_ptr );
d284: e3a01fae mov r1, #696 ; 0x2b8 <== NOT EXECUTED
d288: e2811001 add r1, r1, #1 <== NOT EXECUTED
d28c: e59f0054 ldr r0, [pc, #84] ; d2e8 <IMFS_memfile_read+0x2c0><== NOT EXECUTED
d290: e59f2054 ldr r2, [pc, #84] ; d2ec <IMFS_memfile_read+0x2c4><== NOT EXECUTED
d294: e59f3054 ldr r3, [pc, #84] ; d2f0 <IMFS_memfile_read+0x2c8><== NOT EXECUTED
d298: ebfff62d bl ab54 <__assert_func> <== NOT EXECUTED
/*
* Error checks on arguments
*/
assert( dest );
d29c: e3a01f96 mov r1, #600 ; 0x258 <== NOT EXECUTED
d2a0: e2811002 add r1, r1, #2 <== NOT EXECUTED
d2a4: e59f003c ldr r0, [pc, #60] ; d2e8 <IMFS_memfile_read+0x2c0><== NOT EXECUTED
d2a8: e59f203c ldr r2, [pc, #60] ; d2ec <IMFS_memfile_read+0x2c4><== NOT EXECUTED
d2ac: e59f3044 ldr r3, [pc, #68] ; d2f8 <IMFS_memfile_read+0x2d0><== NOT EXECUTED
d2b0: ebfff627 bl ab54 <__assert_func> <== NOT EXECUTED
assert( the_jnode );
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE ||
d2b4: e3a01e25 mov r1, #592 ; 0x250 <== NOT EXECUTED
d2b8: e2811001 add r1, r1, #1 <== NOT EXECUTED
d2bc: e59f0024 ldr r0, [pc, #36] ; d2e8 <IMFS_memfile_read+0x2c0><== NOT EXECUTED
d2c0: e59f2024 ldr r2, [pc, #36] ; d2ec <IMFS_memfile_read+0x2c4><== NOT EXECUTED
d2c4: e59f3030 ldr r3, [pc, #48] ; d2fc <IMFS_memfile_read+0x2d4><== NOT EXECUTED
d2c8: ebfff621 bl ab54 <__assert_func> <== NOT EXECUTED
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
assert( block_ptr );
d2cc: e3a01fa5 mov r1, #660 ; 0x294 <== NOT EXECUTED
d2d0: e2811002 add r1, r1, #2 <== NOT EXECUTED
d2d4: e59f000c ldr r0, [pc, #12] ; d2e8 <IMFS_memfile_read+0x2c0><== NOT EXECUTED
d2d8: e59f200c ldr r2, [pc, #12] ; d2ec <IMFS_memfile_read+0x2c4><== NOT EXECUTED
d2dc: e59f300c ldr r3, [pc, #12] ; d2f0 <IMFS_memfile_read+0x2c8><== NOT EXECUTED
d2e0: ebfff61b bl ab54 <__assert_func> <== NOT EXECUTED
0000c710 <IMFS_memfile_remove>:
*/
int IMFS_memfile_remove(
IMFS_jnode_t *the_jnode
)
{
c710: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
/*
* Perform internal consistency checks
*/
assert( the_jnode );
c714: e250a000 subs sl, r0, #0
c718: 0a00004f beq c85c <IMFS_memfile_remove+0x14c>
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
c71c: e59a304c ldr r3, [sl, #76] ; 0x4c
c720: e3530005 cmp r3, #5
c724: 1a000052 bne c874 <IMFS_memfile_remove+0x164>
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
c728: e59f615c ldr r6, [pc, #348] ; c88c <IMFS_memfile_remove+0x17c>
* + indirect
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
c72c: e59a3058 ldr r3, [sl, #88] ; 0x58
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
c730: e5967000 ldr r7, [r6]
* + indirect
* + doubly indirect
* + triply indirect
*/
info = &the_jnode->info.file;
c734: e3530000 cmp r3, #0
/*
* Eventually this could be set smarter at each call to
* memfile_free_blocks_in_table to greatly speed this up.
*/
to_free = IMFS_MEMFILE_BLOCK_SLOTS;
c738: e1a07127 lsr r7, r7, #2
*/
info = &the_jnode->info.file;
if ( info->indirect ) {
memfile_free_blocks_in_table( &info->indirect, to_free );
c73c: 128a0058 addne r0, sl, #88 ; 0x58
c740: 11a01007 movne r1, r7
c744: 1bffffbb blne c638 <memfile_free_blocks_in_table>
}
if ( info->doubly_indirect ) {
c748: e59a305c ldr r3, [sl, #92] ; 0x5c
c74c: e3530000 cmp r3, #0
c750: 0a000014 beq c7a8 <IMFS_memfile_remove+0x98>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
c754: e5962000 ldr r2, [r6] <== NOT EXECUTED
c758: e1b02122 lsrs r2, r2, #2 <== NOT EXECUTED
c75c: 0a00000e beq c79c <IMFS_memfile_remove+0x8c> <== NOT EXECUTED
c760: e3a02000 mov r2, #0 <== NOT EXECUTED
c764: e1a04002 mov r4, r2 <== NOT EXECUTED
c768: ea000000 b c770 <IMFS_memfile_remove+0x60> <== NOT EXECUTED
c76c: e59a305c ldr r3, [sl, #92] ; 0x5c <== NOT EXECUTED
if ( info->doubly_indirect[i] ) {
c770: e7931102 ldr r1, [r3, r2, lsl #2] <== NOT EXECUTED
c774: e3510000 cmp r1, #0 <== NOT EXECUTED
c778: e1a02102 lsl r2, r2, #2 <== NOT EXECUTED
memfile_free_blocks_in_table(
c77c: 10830002 addne r0, r3, r2 <== NOT EXECUTED
c780: 11a01007 movne r1, r7 <== NOT EXECUTED
c784: 1bffffab blne c638 <memfile_free_blocks_in_table> <== NOT EXECUTED
memfile_free_blocks_in_table( &info->indirect, to_free );
}
if ( info->doubly_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
c788: e5963000 ldr r3, [r6] <== NOT EXECUTED
c78c: e2844001 add r4, r4, #1 <== NOT EXECUTED
c790: e1540123 cmp r4, r3, lsr #2 <== NOT EXECUTED
c794: e1a02004 mov r2, r4 <== NOT EXECUTED
c798: 3afffff3 bcc c76c <IMFS_memfile_remove+0x5c> <== NOT EXECUTED
if ( info->doubly_indirect[i] ) {
memfile_free_blocks_in_table(
(block_p **)&info->doubly_indirect[i], to_free );
}
}
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
c79c: e28a005c add r0, sl, #92 ; 0x5c <== NOT EXECUTED
c7a0: e1a01007 mov r1, r7 <== NOT EXECUTED
c7a4: ebffffa3 bl c638 <memfile_free_blocks_in_table> <== NOT EXECUTED
}
if ( info->triply_indirect ) {
c7a8: e59a0060 ldr r0, [sl, #96] ; 0x60
c7ac: e3500000 cmp r0, #0
c7b0: 0a000027 beq c854 <IMFS_memfile_remove+0x144>
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
c7b4: e5963000 ldr r3, [r6] <== NOT EXECUTED
c7b8: e1b03123 lsrs r3, r3, #2 <== NOT EXECUTED
c7bc: 0a000021 beq c848 <IMFS_memfile_remove+0x138> <== NOT EXECUTED
p = (block_p *) info->triply_indirect[i];
c7c0: e5905000 ldr r5, [r0] <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
c7c4: e3550000 cmp r5, #0 <== NOT EXECUTED
c7c8: 13a09000 movne r9, #0 <== NOT EXECUTED
c7cc: 11a08009 movne r8, r9 <== NOT EXECUTED
c7d0: 0a00001c beq c848 <IMFS_memfile_remove+0x138> <== NOT EXECUTED
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
c7d4: e3530000 cmp r3, #0 <== NOT EXECUTED
c7d8: 0a00000d beq c814 <IMFS_memfile_remove+0x104> <== NOT EXECUTED
c7dc: e3a00000 mov r0, #0 <== NOT EXECUTED
c7e0: e1a04000 mov r4, r0 <== NOT EXECUTED
if ( p[j] ) {
c7e4: e7953100 ldr r3, [r5, r0, lsl #2] <== NOT EXECUTED
c7e8: e3530000 cmp r3, #0 <== NOT EXECUTED
c7ec: e1a00100 lsl r0, r0, #2 <== NOT EXECUTED
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
c7f0: 10850000 addne r0, r5, r0 <== NOT EXECUTED
c7f4: 11a01007 movne r1, r7 <== NOT EXECUTED
c7f8: 1bffff8e blne c638 <memfile_free_blocks_in_table> <== NOT EXECUTED
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
p = (block_p *) info->triply_indirect[i];
if ( !p ) /* ensure we have a valid pointer */
break;
for ( j=0 ; j<IMFS_MEMFILE_BLOCK_SLOTS ; j++ ) {
c7fc: e5963000 ldr r3, [r6] <== NOT EXECUTED
c800: e2844001 add r4, r4, #1 <== NOT EXECUTED
c804: e1540123 cmp r4, r3, lsr #2 <== NOT EXECUTED
c808: e1a00004 mov r0, r4 <== NOT EXECUTED
c80c: 3afffff4 bcc c7e4 <IMFS_memfile_remove+0xd4> <== NOT EXECUTED
c810: e59a0060 ldr r0, [sl, #96] ; 0x60 <== NOT EXECUTED
if ( p[j] ) {
memfile_free_blocks_in_table( (block_p **)&p[j], to_free);
}
}
memfile_free_blocks_in_table(
c814: e0800009 add r0, r0, r9 <== NOT EXECUTED
c818: e1a01007 mov r1, r7 <== NOT EXECUTED
c81c: ebffff85 bl c638 <memfile_free_blocks_in_table> <== NOT EXECUTED
memfile_free_blocks_in_table( &info->doubly_indirect, to_free );
}
if ( info->triply_indirect ) {
for ( i=0 ; i<IMFS_MEMFILE_BLOCK_SLOTS ; i++ ) {
c820: e5963000 ldr r3, [r6] <== NOT EXECUTED
c824: e2888001 add r8, r8, #1 <== NOT EXECUTED
c828: e1a03123 lsr r3, r3, #2 <== NOT EXECUTED
c82c: e1530008 cmp r3, r8 <== NOT EXECUTED
c830: 9a000004 bls c848 <IMFS_memfile_remove+0x138> <== NOT EXECUTED
p = (block_p *) info->triply_indirect[i];
c834: e59a0060 ldr r0, [sl, #96] ; 0x60 <== NOT EXECUTED
c838: e7905108 ldr r5, [r0, r8, lsl #2] <== NOT EXECUTED
if ( !p ) /* ensure we have a valid pointer */
c83c: e3550000 cmp r5, #0 <== NOT EXECUTED
c840: e1a09108 lsl r9, r8, #2 <== NOT EXECUTED
c844: 1affffe2 bne c7d4 <IMFS_memfile_remove+0xc4> <== NOT EXECUTED
}
}
memfile_free_blocks_in_table(
(block_p **)&info->triply_indirect[i], to_free );
}
memfile_free_blocks_in_table(
c848: e28a0060 add r0, sl, #96 ; 0x60 <== NOT EXECUTED
c84c: e1a01007 mov r1, r7 <== NOT EXECUTED
c850: ebffff78 bl c638 <memfile_free_blocks_in_table> <== NOT EXECUTED
(block_p **)&info->triply_indirect, to_free );
}
return 0;
}
c854: e3a00000 mov r0, #0
c858: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
/*
* Perform internal consistency checks
*/
assert( the_jnode );
c85c: e3a01f7b mov r1, #492 ; 0x1ec <== NOT EXECUTED
c860: e2811002 add r1, r1, #2 <== NOT EXECUTED
c864: e59f0024 ldr r0, [pc, #36] ; c890 <IMFS_memfile_remove+0x180><== NOT EXECUTED
c868: e59f2024 ldr r2, [pc, #36] ; c894 <IMFS_memfile_remove+0x184><== NOT EXECUTED
c86c: e59f3024 ldr r3, [pc, #36] ; c898 <IMFS_memfile_remove+0x188><== NOT EXECUTED
c870: ebfff8b7 bl ab54 <__assert_func> <== NOT EXECUTED
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
c874: e3a01e1f mov r1, #496 ; 0x1f0 <== NOT EXECUTED
c878: e2811002 add r1, r1, #2 <== NOT EXECUTED
c87c: e59f000c ldr r0, [pc, #12] ; c890 <IMFS_memfile_remove+0x180><== NOT EXECUTED
c880: e59f200c ldr r2, [pc, #12] ; c894 <IMFS_memfile_remove+0x184><== NOT EXECUTED
c884: e59f3010 ldr r3, [pc, #16] ; c89c <IMFS_memfile_remove+0x18c><== NOT EXECUTED
c888: ebfff8b1 bl ab54 <__assert_func> <== NOT EXECUTED
0000c6c0 <IMFS_memfile_remove_block>:
MEMFILE_STATIC int IMFS_memfile_remove_block(
IMFS_jnode_t *the_jnode,
unsigned int block
)
{
c6c0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
block_p *block_ptr;
block_p ptr;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
c6c4: e3a02000 mov r2, #0 <== NOT EXECUTED
c6c8: ebffff4e bl c408 <IMFS_memfile_get_block_pointer> <== NOT EXECUTED
assert( block_ptr );
c6cc: e2503000 subs r3, r0, #0 <== NOT EXECUTED
c6d0: 0a000005 beq c6ec <IMFS_memfile_remove_block+0x2c> <== NOT EXECUTED
if ( block_ptr ) {
ptr = *block_ptr;
*block_ptr = 0;
c6d4: e3a02000 mov r2, #0 <== NOT EXECUTED
block_p ptr;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
assert( block_ptr );
if ( block_ptr ) {
ptr = *block_ptr;
c6d8: e5930000 ldr r0, [r3] <== NOT EXECUTED
*block_ptr = 0;
c6dc: e5832000 str r2, [r3] <== NOT EXECUTED
memfile_free_block( ptr );
c6e0: ebffff33 bl c3b4 <memfile_free_block> <== NOT EXECUTED
}
return 1;
}
c6e4: e3a00001 mov r0, #1 <== NOT EXECUTED
c6e8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
block_p *block_ptr;
block_p ptr;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
assert( block_ptr );
c6ec: e3a01f65 mov r1, #404 ; 0x194 <== NOT EXECUTED
c6f0: e2811002 add r1, r1, #2 <== NOT EXECUTED
c6f4: e59f0008 ldr r0, [pc, #8] ; c704 <IMFS_memfile_remove_block+0x44><== NOT EXECUTED
c6f8: e59f2008 ldr r2, [pc, #8] ; c708 <IMFS_memfile_remove_block+0x48><== NOT EXECUTED
c6fc: e59f3008 ldr r3, [pc, #8] ; c70c <IMFS_memfile_remove_block+0x4c><== NOT EXECUTED
c700: ebfff913 bl ab54 <__assert_func> <== NOT EXECUTED
0000cca4 <IMFS_memfile_write>:
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
cca4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
/*
* Perform internal consistency checks
*/
assert( the_jnode );
cca8: e2509000 subs r9, r0, #0
IMFS_jnode_t *the_jnode,
off_t start,
const unsigned char *source,
unsigned int length
)
{
ccac: e24dd014 sub sp, sp, #20
ccb0: e1a06001 mov r6, r1
ccb4: e1a07002 mov r7, r2
ccb8: e1a08003 mov r8, r3
ccbc: e59da038 ldr sl, [sp, #56] ; 0x38
/*
* Perform internal consistency checks
*/
assert( the_jnode );
ccc0: 0a000079 beq ceac <IMFS_memfile_write+0x208>
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
ccc4: e599304c ldr r3, [r9, #76] ; 0x4c
ccc8: e3530005 cmp r3, #5
cccc: 1a000070 bne ce94 <IMFS_memfile_write+0x1f0>
/*
* Error check arguments
*/
assert( source );
ccd0: e3580000 cmp r8, #0
ccd4: 0a000085 beq cef0 <IMFS_memfile_write+0x24c>
/*
* If there is nothing to write, then quick exit.
*/
my_length = length;
if ( !my_length )
ccd8: e35a0000 cmp sl, #0
ccdc: 0a000062 beq ce6c <IMFS_memfile_write+0x1c8>
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size ) {
cce0: e5993054 ldr r3, [r9, #84] ; 0x54
cce4: e3530000 cmp r3, #0
cce8: e08a1001 add r1, sl, r1
ccec: ba000054 blt ce44 <IMFS_memfile_write+0x1a0>
ccf0: 0a000050 beq ce38 <IMFS_memfile_write+0x194>
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
ccf4: e59f520c ldr r5, [pc, #524] ; cf08 <IMFS_memfile_write+0x264>
ccf8: e5954000 ldr r4, [r5]
ccfc: e1a00006 mov r0, r6
cd00: e1a02004 mov r2, r4
cd04: e1a03fc2 asr r3, r2, #31
cd08: e1a01007 mov r1, r7
cd0c: e98d000c stmib sp, {r2, r3}
cd10: eb002f0f bl 18954 <__moddi3>
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
cd14: e1a01007 mov r1, r7
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
cd18: e1a0b000 mov fp, r0
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
cd1c: e99d000c ldmib sp, {r2, r3}
cd20: e1a00006 mov r0, r6
cd24: eb002de0 bl 184ac <__divdi3>
if ( start_offset ) {
cd28: e35b0000 cmp fp, #0
cd2c: 01a0700a moveq r7, sl
/*
* Phase 1: possibly the last part of one block
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
cd30: e1a06000 mov r6, r0
if ( start_offset ) {
cd34: 01a0a00b moveq sl, fp
cd38: 1a000028 bne cde0 <IMFS_memfile_write+0x13c>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
cd3c: e1570004 cmp r7, r4
cd40: 3a000010 bcc cd88 <IMFS_memfile_write+0xe4>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
cd44: e1a00009 mov r0, r9
cd48: e1a01006 mov r1, r6
cd4c: e3a02000 mov r2, #0
cd50: ebfffdac bl c408 <IMFS_memfile_get_block_pointer>
assert( block_ptr );
cd54: e3500000 cmp r0, #0
cd58: 0a000048 beq ce80 <IMFS_memfile_write+0x1dc>
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
cd5c: e1a01008 mov r1, r8
cd60: e5900000 ldr r0, [r0]
cd64: e1a02004 mov r2, r4
cd68: eb000762 bl eaf8 <memcpy>
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
cd6c: e5953000 ldr r3, [r5]
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
src += to_copy;
block++;
my_length -= to_copy;
cd70: e0647007 rsb r7, r4, r7
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
cd74: e1530007 cmp r3, r7
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, to_copy );
src += to_copy;
cd78: e0888004 add r8, r8, r4
block++;
cd7c: e2866001 add r6, r6, #1
*
* This routine writes the specified data buffer into the in memory
* file pointed to by the_jnode. The file is extended as needed.
*/
MEMFILE_STATIC ssize_t IMFS_memfile_write(
cd80: e08aa004 add sl, sl, r4
/*
* Phase 2: all of zero of more blocks
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
cd84: 9affffee bls cd44 <IMFS_memfile_write+0xa0>
*/
assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
cd88: e3570000 cmp r7, #0
cd8c: 0a00000a beq cdbc <IMFS_memfile_write+0x118>
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
cd90: e1a01006 mov r1, r6
cd94: e1a00009 mov r0, r9
cd98: e3a02000 mov r2, #0
cd9c: ebfffd99 bl c408 <IMFS_memfile_get_block_pointer>
assert( block_ptr );
cda0: e3500000 cmp r0, #0
cda4: 0a00004b beq ced8 <IMFS_memfile_write+0x234>
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d in %d: %*s\n", to_copy, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ 0 ], src, my_length );
cda8: e5900000 ldr r0, [r0]
cdac: e1a01008 mov r1, r8
cdb0: e1a02007 mov r2, r7
cdb4: eb00074f bl eaf8 <memcpy>
my_length = 0;
copied += to_copy;
cdb8: e08aa007 add sl, sl, r7
}
IMFS_mtime_ctime_update( the_jnode );
cdbc: e28d000c add r0, sp, #12
cdc0: e3a01000 mov r1, #0
cdc4: ebffd4e0 bl 214c <gettimeofday>
cdc8: e59d300c ldr r3, [sp, #12]
cdcc: e5893048 str r3, [r9, #72] ; 0x48
cdd0: e5893044 str r3, [r9, #68] ; 0x44
return copied;
}
cdd4: e1a0000a mov r0, sl
cdd8: e28dd014 add sp, sp, #20
cddc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
cde0: e1a00009 mov r0, r9
cde4: e1a01006 mov r1, r6
cde8: e3a02000 mov r2, #0
cdec: ebfffd85 bl c408 <IMFS_memfile_get_block_pointer>
assert( block_ptr );
cdf0: e3500000 cmp r0, #0
cdf4: 0a000032 beq cec4 <IMFS_memfile_write+0x220>
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
cdf8: e06b3004 rsb r3, fp, r4
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d at %d in %d: %*s\n", to_copy, start_offset, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
cdfc: e5900000 ldr r0, [r0]
*/
start_offset = start % IMFS_MEMFILE_BYTES_PER_BLOCK;
block = start / IMFS_MEMFILE_BYTES_PER_BLOCK;
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
ce00: e153000a cmp r3, sl
ce04: 21a0300a movcs r3, sl
if ( !block_ptr )
return copied;
#if 0
fprintf(stdout, "write %d at %d in %d: %*s\n", to_copy, start_offset, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
ce08: e1a01008 mov r1, r8
ce0c: e1a02003 mov r2, r3
ce10: e080000b add r0, r0, fp
ce14: e58d3000 str r3, [sp]
ce18: eb000736 bl eaf8 <memcpy>
src += to_copy;
ce1c: e59d3000 ldr r3, [sp]
block++;
my_length -= to_copy;
copied += to_copy;
ce20: e5954000 ldr r4, [r5]
fprintf(stdout, "write %d at %d in %d: %*s\n", to_copy, start_offset, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
src += to_copy;
block++;
my_length -= to_copy;
ce24: e063700a rsb r7, r3, sl
return copied;
#if 0
fprintf(stdout, "write %d at %d in %d: %*s\n", to_copy, start_offset, block, to_copy, src );
#endif
memcpy( &(*block_ptr)[ start_offset ], src, to_copy );
src += to_copy;
ce28: e0888003 add r8, r8, r3
block++;
ce2c: e2866001 add r6, r6, #1
my_length -= to_copy;
copied += to_copy;
ce30: e1a0a003 mov sl, r3
ce34: eaffffc0 b cd3c <IMFS_memfile_write+0x98>
* If the last byte we are supposed to write is past the end of this
* in memory file, then extend the length.
*/
last_byte = start + length;
if ( last_byte > the_jnode->info.file.size ) {
ce38: e5993050 ldr r3, [r9, #80] ; 0x50
ce3c: e1530001 cmp r3, r1
ce40: 2affffab bcs ccf4 <IMFS_memfile_write+0x50>
status = IMFS_memfile_extend( the_jnode, last_byte );
ce44: e1a00009 mov r0, r9
ce48: e3a02000 mov r2, #0
ce4c: ebfffeee bl ca0c <IMFS_memfile_extend>
if ( status )
ce50: e3500000 cmp r0, #0
ce54: 0affffa6 beq ccf4 <IMFS_memfile_write+0x50>
rtems_set_errno_and_return_minus_one( ENOSPC );
ce58: eb000518 bl e2c0 <__errno> <== NOT EXECUTED
ce5c: e3a0301c mov r3, #28 <== NOT EXECUTED
ce60: e5803000 str r3, [r0] <== NOT EXECUTED
ce64: e3e0a000 mvn sl, #0 <== NOT EXECUTED
ce68: eaffffd9 b cdd4 <IMFS_memfile_write+0x130> <== NOT EXECUTED
* If there is nothing to write, then quick exit.
*/
my_length = length;
if ( !my_length )
rtems_set_errno_and_return_minus_one( EINVAL );
ce6c: eb000513 bl e2c0 <__errno> <== NOT EXECUTED
ce70: e3a03016 mov r3, #22 <== NOT EXECUTED
ce74: e5803000 str r3, [r0] <== NOT EXECUTED
ce78: e3e0a000 mvn sl, #0 <== NOT EXECUTED
ce7c: eaffffd4 b cdd4 <IMFS_memfile_write+0x130> <== NOT EXECUTED
*/
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK;
while ( my_length >= IMFS_MEMFILE_BYTES_PER_BLOCK ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
assert( block_ptr );
ce80: e59f0084 ldr r0, [pc, #132] ; cf0c <IMFS_memfile_write+0x268><== NOT EXECUTED
ce84: e3a01e33 mov r1, #816 ; 0x330 <== NOT EXECUTED
ce88: e59f2080 ldr r2, [pc, #128] ; cf10 <IMFS_memfile_write+0x26c><== NOT EXECUTED
ce8c: e59f3080 ldr r3, [pc, #128] ; cf14 <IMFS_memfile_write+0x270><== NOT EXECUTED
ce90: ebfff72f bl ab54 <__assert_func> <== NOT EXECUTED
assert( the_jnode );
if ( !the_jnode )
rtems_set_errno_and_return_minus_one( EIO );
assert( the_jnode->type == IMFS_MEMORY_FILE );
ce94: e3a01fb9 mov r1, #740 ; 0x2e4 <== NOT EXECUTED
ce98: e2811003 add r1, r1, #3 <== NOT EXECUTED
ce9c: e59f0068 ldr r0, [pc, #104] ; cf0c <IMFS_memfile_write+0x268><== NOT EXECUTED
cea0: e59f2068 ldr r2, [pc, #104] ; cf10 <IMFS_memfile_write+0x26c><== NOT EXECUTED
cea4: e59f306c ldr r3, [pc, #108] ; cf18 <IMFS_memfile_write+0x274><== NOT EXECUTED
cea8: ebfff729 bl ab54 <__assert_func> <== NOT EXECUTED
/*
* Perform internal consistency checks
*/
assert( the_jnode );
ceac: e3a01e2e mov r1, #736 ; 0x2e0 <== NOT EXECUTED
ceb0: e2811003 add r1, r1, #3 <== NOT EXECUTED
ceb4: e59f0050 ldr r0, [pc, #80] ; cf0c <IMFS_memfile_write+0x268><== NOT EXECUTED
ceb8: e59f2050 ldr r2, [pc, #80] ; cf10 <IMFS_memfile_write+0x26c><== NOT EXECUTED
cebc: e59f3058 ldr r3, [pc, #88] ; cf1c <IMFS_memfile_write+0x278><== NOT EXECUTED
cec0: ebfff723 bl ab54 <__assert_func> <== NOT EXECUTED
if ( start_offset ) {
to_copy = IMFS_MEMFILE_BYTES_PER_BLOCK - start_offset;
if ( to_copy > my_length )
to_copy = my_length;
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
assert( block_ptr );
cec4: e59f0040 ldr r0, [pc, #64] ; cf0c <IMFS_memfile_write+0x268><== NOT EXECUTED
cec8: e3a01fc7 mov r1, #796 ; 0x31c <== NOT EXECUTED
cecc: e59f203c ldr r2, [pc, #60] ; cf10 <IMFS_memfile_write+0x26c><== NOT EXECUTED
ced0: e59f303c ldr r3, [pc, #60] ; cf14 <IMFS_memfile_write+0x270><== NOT EXECUTED
ced4: ebfff71e bl ab54 <__assert_func> <== NOT EXECUTED
assert( my_length < IMFS_MEMFILE_BYTES_PER_BLOCK );
to_copy = my_length;
if ( my_length ) {
block_ptr = IMFS_memfile_get_block_pointer( the_jnode, block, 0 );
assert( block_ptr );
ced8: e3a01fd1 mov r1, #836 ; 0x344 <== NOT EXECUTED
cedc: e2811002 add r1, r1, #2 <== NOT EXECUTED
cee0: e59f0024 ldr r0, [pc, #36] ; cf0c <IMFS_memfile_write+0x268><== NOT EXECUTED
cee4: e59f2024 ldr r2, [pc, #36] ; cf10 <IMFS_memfile_write+0x26c><== NOT EXECUTED
cee8: e59f3024 ldr r3, [pc, #36] ; cf14 <IMFS_memfile_write+0x270><== NOT EXECUTED
ceec: ebfff718 bl ab54 <__assert_func> <== NOT EXECUTED
/*
* Error check arguments
*/
assert( source );
cef0: e3a01fbb mov r1, #748 ; 0x2ec <== NOT EXECUTED
cef4: e2811003 add r1, r1, #3 <== NOT EXECUTED
cef8: e59f000c ldr r0, [pc, #12] ; cf0c <IMFS_memfile_write+0x268><== NOT EXECUTED
cefc: e59f200c ldr r2, [pc, #12] ; cf10 <IMFS_memfile_write+0x26c><== NOT EXECUTED
cf00: e59f3018 ldr r3, [pc, #24] ; cf20 <IMFS_memfile_write+0x27c><== NOT EXECUTED
cf04: ebfff712 bl ab54 <__assert_func> <== NOT EXECUTED
00001818 <IMFS_mknod>:
const char *token, /* IN */
mode_t mode, /* IN */
dev_t dev, /* IN */
rtems_filesystem_location_info_t *pathloc /* IN/OUT */
)
{
1818: e92d41f0 push {r4, r5, r6, r7, r8, lr}
181c: e24dd040 sub sp, sp, #64 ; 0x40
1820: e1a04001 mov r4, r1
1824: e1a07002 mov r7, r2
1828: e1a06003 mov r6, r3
182c: e1a08000 mov r8, r0
IMFS_jnode_t *new_node;
int result;
char new_name[ IMFS_NAME_MAX + 1 ];
IMFS_types_union info;
IMFS_get_token( token, strlen( token ), new_name, &result );
1830: eb0036a7 bl f2d4 <strlen>
1834: e28d5004 add r5, sp, #4
1838: e1a01000 mov r1, r0
183c: e28d303c add r3, sp, #60 ; 0x3c
1840: e1a00008 mov r0, r8
1844: e1a02005 mov r2, r5
1848: eb002422 bl a8d8 <IMFS_get_token>
/*
* Figure out what type of IMFS node this is.
*/
if ( S_ISDIR(mode) )
184c: e2043a0f and r3, r4, #61440 ; 0xf000
1850: e3530901 cmp r3, #16384 ; 0x4000
1854: 0a00001b beq 18c8 <IMFS_mknod+0xb0>
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
1858: e3530902 cmp r3, #32768 ; 0x8000
185c: 03a01005 moveq r1, #5
1860: 0a000005 beq 187c <IMFS_mknod+0x64>
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
1864: e3530a06 cmp r3, #24576 ; 0x6000
1868: 13530a02 cmpne r3, #8192 ; 0x2000
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
186c: 058d7028 streq r7, [sp, #40] ; 0x28
1870: 058d602c streq r6, [sp, #44] ; 0x2c
1874: 03a01002 moveq r1, #2
*/
if ( S_ISDIR(mode) )
type = IMFS_DIRECTORY;
else if ( S_ISREG(mode) )
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
1878: 1a00000a bne 18a8 <IMFS_mknod+0x90>
* was ONLY passed a NULL when we created the root node. We
* added a new IMFS_create_root_node() so this path no longer
* existed. The result was simpler code which should not have
* this path.
*/
new_node = IMFS_create_node(
187c: e28dc028 add ip, sp, #40 ; 0x28
1880: e59d0058 ldr r0, [sp, #88] ; 0x58
1884: e1a02005 mov r2, r5
1888: e1a03004 mov r3, r4
188c: e58dc000 str ip, [sp]
1890: eb002092 bl 9ae0 <IMFS_create_node>
new_name,
mode,
&info
);
if ( !new_node )
1894: e3500000 cmp r0, #0
1898: 13a00000 movne r0, #0
189c: 0a00000b beq 18d0 <IMFS_mknod+0xb8>
rtems_set_errno_and_return_minus_one( ENOMEM );
return 0;
}
18a0: e28dd040 add sp, sp, #64 ; 0x40
18a4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
type = IMFS_MEMORY_FILE;
else if ( S_ISBLK(mode) || S_ISCHR(mode) ) {
type = IMFS_DEVICE;
rtems_filesystem_split_dev_t( dev, info.device.major, info.device.minor );
}
else if (S_ISFIFO(mode))
18a8: e3530a01 cmp r3, #4096 ; 0x1000
18ac: 03a01007 moveq r1, #7
18b0: 0afffff1 beq 187c <IMFS_mknod+0x64>
type = IMFS_FIFO;
else {
rtems_set_errno_and_return_minus_one( EINVAL );
18b4: eb003281 bl e2c0 <__errno> <== NOT EXECUTED
18b8: e3a03016 mov r3, #22 <== NOT EXECUTED
18bc: e5803000 str r3, [r0] <== NOT EXECUTED
18c0: e3e00000 mvn r0, #0 <== NOT EXECUTED
18c4: eafffff5 b 18a0 <IMFS_mknod+0x88> <== NOT EXECUTED
18c8: e3a01001 mov r1, #1
18cc: eaffffea b 187c <IMFS_mknod+0x64>
mode,
&info
);
if ( !new_node )
rtems_set_errno_and_return_minus_one( ENOMEM );
18d0: eb00327a bl e2c0 <__errno> <== NOT EXECUTED
18d4: e3a0300c mov r3, #12 <== NOT EXECUTED
18d8: e5803000 str r3, [r0] <== NOT EXECUTED
18dc: e3e00000 mvn r0, #0 <== NOT EXECUTED
18e0: eaffffee b 18a0 <IMFS_mknod+0x88> <== NOT EXECUTED
000018e4 <IMFS_mount>:
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
18e4: e5903008 ldr r3, [r0, #8]
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
18e8: e593204c ldr r2, [r3, #76] ; 0x4c
18ec: e3520001 cmp r2, #1
#include <rtems/seterr.h>
int IMFS_mount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
18f0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
18f4: 1a000002 bne 1904 <IMFS_mount+0x20>
/*
* Set mt_fs pointer to point to the mount table entry for
* the mounted file system.
*/
node->info.directory.mt_fs = mt_entry;
18f8: e583005c str r0, [r3, #92] ; 0x5c
18fc: e3a00000 mov r0, #0
return 0; }
1900: e49df004 pop {pc} ; (ldr pc, [sp], #4)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
1904: eb00326d bl e2c0 <__errno> <== NOT EXECUTED
1908: e3a03014 mov r3, #20 <== NOT EXECUTED
190c: e5803000 str r3, [r0] <== NOT EXECUTED
1910: e3e00000 mvn r0, #0 <== NOT EXECUTED
1914: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00003d80 <IMFS_print_jnode>:
*/
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
3d80: e92d4030 push {r4, r5, lr}
assert( the_jnode );
3d84: e2504000 subs r4, r0, #0
3d88: 0a000055 beq 3ee4 <IMFS_print_jnode+0x164>
fprintf(stdout, "%s", the_jnode->name );
3d8c: e59f5164 ldr r5, [pc, #356] ; 3ef8 <IMFS_print_jnode+0x178>
3d90: e5953000 ldr r3, [r5]
3d94: e284000c add r0, r4, #12
3d98: e5931008 ldr r1, [r3, #8]
3d9c: eb003b3e bl 12a9c <fputs>
switch( the_jnode->type ) {
3da0: e594204c ldr r2, [r4, #76] ; 0x4c
3da4: e2423001 sub r3, r2, #1
3da8: e3530006 cmp r3, #6
3dac: 979ff103 ldrls pc, [pc, r3, lsl #2]
3db0: ea000011 b 3dfc <IMFS_print_jnode+0x7c> <== NOT EXECUTED
3db4: 00003e20 .word 0x00003e20 <== NOT EXECUTED
3db8: 00003e3c .word 0x00003e3c <== NOT EXECUTED
3dbc: 00003e58 .word 0x00003e58 <== NOT EXECUTED
3dc0: 00003e84 .word 0x00003e84 <== NOT EXECUTED
3dc4: 00003eb0 .word 0x00003eb0 <== NOT EXECUTED
3dc8: 00003ec8 .word 0x00003ec8 <== NOT EXECUTED
3dcc: 00003dd0 .word 0x00003dd0 <== NOT EXECUTED
fprintf(stdout, " links not printed\n" );
assert(0);
break;
case IMFS_FIFO:
fprintf(stdout, " FIFO not printed\n" );
3dd0: e5953000 ldr r3, [r5] <== NOT EXECUTED
3dd4: e3a01001 mov r1, #1 <== NOT EXECUTED
3dd8: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
3ddc: e3a02012 mov r2, #18 <== NOT EXECUTED
3de0: e59f0114 ldr r0, [pc, #276] ; 3efc <IMFS_print_jnode+0x17c><== NOT EXECUTED
3de4: eb003e41 bl 136f0 <fwrite> <== NOT EXECUTED
assert(0);
3de8: e59f0110 ldr r0, [pc, #272] ; 3f00 <IMFS_print_jnode+0x180><== NOT EXECUTED
3dec: e3a01067 mov r1, #103 ; 0x67 <== NOT EXECUTED
3df0: e59f210c ldr r2, [pc, #268] ; 3f04 <IMFS_print_jnode+0x184><== NOT EXECUTED
3df4: e59f310c ldr r3, [pc, #268] ; 3f08 <IMFS_print_jnode+0x188><== NOT EXECUTED
3df8: eb00029b bl 486c <__assert_func> <== NOT EXECUTED
break;
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
3dfc: e5953000 ldr r3, [r5] <== NOT EXECUTED
3e00: e59f1104 ldr r1, [pc, #260] ; 3f0c <IMFS_print_jnode+0x18c><== NOT EXECUTED
3e04: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
3e08: eb003ac2 bl 12918 <fprintf> <== NOT EXECUTED
assert(0);
3e0c: e59f00ec ldr r0, [pc, #236] ; 3f00 <IMFS_print_jnode+0x180><== NOT EXECUTED
3e10: e3a0106c mov r1, #108 ; 0x6c <== NOT EXECUTED
3e14: e59f20e8 ldr r2, [pc, #232] ; 3f04 <IMFS_print_jnode+0x184><== NOT EXECUTED
3e18: e59f30e8 ldr r3, [pc, #232] ; 3f08 <IMFS_print_jnode+0x188><== NOT EXECUTED
3e1c: eb000292 bl 486c <__assert_func> <== NOT EXECUTED
assert( the_jnode );
fprintf(stdout, "%s", the_jnode->name );
switch( the_jnode->type ) {
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
3e20: e5953000 ldr r3, [r5]
3e24: e3a0002f mov r0, #47 ; 0x2f
3e28: e5931008 ldr r1, [r3, #8]
3e2c: eb003ad5 bl 12988 <fputc>
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
assert(0);
break;
}
puts("");
3e30: e59f00d8 ldr r0, [pc, #216] ; 3f10 <IMFS_print_jnode+0x190>
}
3e34: e8bd4030 pop {r4, r5, lr}
default:
fprintf(stdout, " bad type %d\n", the_jnode->type );
assert(0);
break;
}
puts("");
3e38: ea00421e b 146b8 <puts>
case IMFS_DIRECTORY:
fprintf(stdout, "/" );
break;
case IMFS_DEVICE:
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
3e3c: e5952000 ldr r2, [r5]
3e40: e5943054 ldr r3, [r4, #84] ; 0x54
3e44: e5920008 ldr r0, [r2, #8]
3e48: e59f10c4 ldr r1, [pc, #196] ; 3f14 <IMFS_print_jnode+0x194>
3e4c: e5942050 ldr r2, [r4, #80] ; 0x50
3e50: eb003ab0 bl 12918 <fprintf>
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
3e54: eafffff5 b 3e30 <IMFS_print_jnode+0xb0>
(uint32_t)the_jnode->info.file.size );
#endif
break;
case IMFS_HARD_LINK:
fprintf(stdout, " links not printed\n" );
3e58: e5953000 ldr r3, [r5] <== NOT EXECUTED
3e5c: e3a01001 mov r1, #1 <== NOT EXECUTED
3e60: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
3e64: e3a02013 mov r2, #19 <== NOT EXECUTED
3e68: e59f00a8 ldr r0, [pc, #168] ; 3f18 <IMFS_print_jnode+0x198><== NOT EXECUTED
3e6c: eb003e1f bl 136f0 <fwrite> <== NOT EXECUTED
assert(0);
3e70: e59f0088 ldr r0, [pc, #136] ; 3f00 <IMFS_print_jnode+0x180><== NOT EXECUTED
3e74: e3a0105d mov r1, #93 ; 0x5d <== NOT EXECUTED
3e78: e59f2084 ldr r2, [pc, #132] ; 3f04 <IMFS_print_jnode+0x184><== NOT EXECUTED
3e7c: e59f3084 ldr r3, [pc, #132] ; 3f08 <IMFS_print_jnode+0x188><== NOT EXECUTED
3e80: eb000279 bl 486c <__assert_func> <== NOT EXECUTED
break;
case IMFS_SYM_LINK:
fprintf(stdout, " links not printed\n" );
3e84: e5953000 ldr r3, [r5] <== NOT EXECUTED
3e88: e3a01001 mov r1, #1 <== NOT EXECUTED
3e8c: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
3e90: e3a02013 mov r2, #19 <== NOT EXECUTED
3e94: e59f007c ldr r0, [pc, #124] ; 3f18 <IMFS_print_jnode+0x198><== NOT EXECUTED
3e98: eb003e14 bl 136f0 <fwrite> <== NOT EXECUTED
assert(0);
3e9c: e59f005c ldr r0, [pc, #92] ; 3f00 <IMFS_print_jnode+0x180> <== NOT EXECUTED
3ea0: e3a01062 mov r1, #98 ; 0x62 <== NOT EXECUTED
3ea4: e59f2058 ldr r2, [pc, #88] ; 3f04 <IMFS_print_jnode+0x184> <== NOT EXECUTED
3ea8: e59f3058 ldr r3, [pc, #88] ; 3f08 <IMFS_print_jnode+0x188> <== NOT EXECUTED
3eac: eb00026e bl 486c <__assert_func> <== NOT EXECUTED
the_jnode->info.file.indirect,
the_jnode->info.file.doubly_indirect,
the_jnode->info.file.triply_indirect
);
#else
fprintf(stdout, " (file %" PRId32 ")",
3eb0: e5953000 ldr r3, [r5]
3eb4: e5942050 ldr r2, [r4, #80] ; 0x50
3eb8: e5930008 ldr r0, [r3, #8]
3ebc: e59f1058 ldr r1, [pc, #88] ; 3f1c <IMFS_print_jnode+0x19c>
3ec0: eb003a94 bl 12918 <fprintf>
(uint32_t)the_jnode->info.file.size );
#endif
break;
3ec4: eaffffd9 b 3e30 <IMFS_print_jnode+0xb0>
fprintf(stdout, " (device %" PRId32 ", %" PRId32 ")",
the_jnode->info.device.major, the_jnode->info.device.minor );
break;
case IMFS_LINEAR_FILE:
fprintf(stdout, " (file %" PRId32 " %p)",
3ec8: e5952000 ldr r2, [r5] <== NOT EXECUTED
3ecc: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED
3ed0: e5920008 ldr r0, [r2, #8] <== NOT EXECUTED
3ed4: e59f1044 ldr r1, [pc, #68] ; 3f20 <IMFS_print_jnode+0x1a0> <== NOT EXECUTED
3ed8: e5942050 ldr r2, [r4, #80] ; 0x50 <== NOT EXECUTED
3edc: eb003a8d bl 12918 <fprintf> <== NOT EXECUTED
(uint32_t)the_jnode->info.linearfile.size,
the_jnode->info.linearfile.direct
);
break;
3ee0: eaffffd2 b 3e30 <IMFS_print_jnode+0xb0> <== NOT EXECUTED
void IMFS_print_jnode(
IMFS_jnode_t *the_jnode
)
{
assert( the_jnode );
3ee4: e59f0014 ldr r0, [pc, #20] ; 3f00 <IMFS_print_jnode+0x180> <== NOT EXECUTED
3ee8: e3a01038 mov r1, #56 ; 0x38 <== NOT EXECUTED
3eec: e59f2010 ldr r2, [pc, #16] ; 3f04 <IMFS_print_jnode+0x184> <== NOT EXECUTED
3ef0: e59f302c ldr r3, [pc, #44] ; 3f24 <IMFS_print_jnode+0x1a4> <== NOT EXECUTED
3ef4: eb00025c bl 486c <__assert_func> <== NOT EXECUTED
00001924 <IMFS_readlink>:
)
{
IMFS_jnode_t *node;
int i;
node = loc->node_access;
1924: e5903000 ldr r3, [r0]
if ( node->type != IMFS_SYM_LINK )
1928: e593004c ldr r0, [r3, #76] ; 0x4c
192c: e3500004 cmp r0, #4
int IMFS_readlink(
rtems_filesystem_location_info_t *loc,
char *buf, /* OUT */
size_t bufsize
)
{
1930: e92d4010 push {r4, lr}
IMFS_jnode_t *node;
int i;
node = loc->node_access;
if ( node->type != IMFS_SYM_LINK )
1934: 1a000013 bne 1988 <IMFS_readlink+0x64>
rtems_set_errno_and_return_minus_one( EINVAL );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
1938: e3520000 cmp r2, #0
193c: 0a00000f beq 1980 <IMFS_readlink+0x5c>
1940: e5930050 ldr r0, [r3, #80] ; 0x50
1944: e5d0c000 ldrb ip, [r0]
1948: e35c0000 cmp ip, #0
int i;
node = loc->node_access;
if ( node->type != IMFS_SYM_LINK )
rtems_set_errno_and_return_minus_one( EINVAL );
194c: 13a04000 movne r4, #0
1950: 11a00004 movne r0, r4
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
1954: 0a000009 beq 1980 <IMFS_readlink+0x5c>
1958: e2800001 add r0, r0, #1
195c: e1520000 cmp r2, r0
buf[i] = node->info.sym_link.name[i];
1960: e7c1c004 strb ip, [r1, r4]
node = loc->node_access;
if ( node->type != IMFS_SYM_LINK )
rtems_set_errno_and_return_minus_one( EINVAL );
for( i=0; ((i<bufsize) && (node->info.sym_link.name[i] != '\0')); i++ )
1964: e1a04000 mov r4, r0
1968: 98bd8010 popls {r4, pc}
196c: e593c050 ldr ip, [r3, #80] ; 0x50
1970: e7dcc000 ldrb ip, [ip, r0]
1974: e35c0000 cmp ip, #0
1978: 1afffff6 bne 1958 <IMFS_readlink+0x34>
197c: e8bd8010 pop {r4, pc}
1980: e3a00000 mov r0, #0 <== NOT EXECUTED
buf[i] = node->info.sym_link.name[i];
return i;
}
1984: e8bd8010 pop {r4, pc} <== NOT EXECUTED
int i;
node = loc->node_access;
if ( node->type != IMFS_SYM_LINK )
rtems_set_errno_and_return_minus_one( EINVAL );
1988: eb00324c bl e2c0 <__errno> <== NOT EXECUTED
198c: e3a03016 mov r3, #22 <== NOT EXECUTED
1990: e5803000 str r3, [r0] <== NOT EXECUTED
1994: e3e00000 mvn r0, #0 <== NOT EXECUTED
1998: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0000aa60 <IMFS_stat>:
{
IMFS_fs_info_t *fs_info;
IMFS_jnode_t *the_jnode;
IMFS_device_t *io;
the_jnode = loc->node_access;
aa60: e5903000 ldr r3, [r0]
switch ( the_jnode->type ) {
aa64: e593204c ldr r2, [r3, #76] ; 0x4c
aa68: e2422002 sub r2, r2, #2
int IMFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
aa6c: e92d4030 push {r4, r5, lr}
IMFS_device_t *io;
the_jnode = loc->node_access;
switch ( the_jnode->type ) {
aa70: e3520005 cmp r2, #5
aa74: 979ff102 ldrls pc, [pc, r2, lsl #2]
aa78: ea00002a b ab28 <IMFS_stat+0xc8> <== NOT EXECUTED
aa7c: 0000ab14 .word 0x0000ab14 <== NOT EXECUTED
aa80: 0000ab28 .word 0x0000ab28 <== NOT EXECUTED
aa84: 0000aa94 .word 0x0000aa94 <== NOT EXECUTED
aa88: 0000ab3c .word 0x0000ab3c <== NOT EXECUTED
aa8c: 0000ab3c .word 0x0000ab3c <== NOT EXECUTED
aa90: 0000aa94 .word 0x0000aa94 <== NOT EXECUTED
case IMFS_SYM_LINK:
buf->st_size = 0;
break;
case IMFS_FIFO:
buf->st_size = 0;
aa94: e3a04000 mov r4, #0 <== NOT EXECUTED
aa98: e3a05000 mov r5, #0 <== NOT EXECUTED
aa9c: e5814020 str r4, [r1, #32] <== NOT EXECUTED
aaa0: e5815024 str r5, [r1, #36] ; 0x24 <== NOT EXECUTED
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
aaa4: e5932030 ldr r2, [r3, #48] ; 0x30
aaa8: e581200c str r2, [r1, #12]
buf->st_nlink = the_jnode->st_nlink; buf->st_ino = the_jnode->st_ino;
aaac: e5932038 ldr r2, [r3, #56] ; 0x38
aab0: e5812008 str r2, [r1, #8]
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
aab4: e5932040 ldr r2, [r3, #64] ; 0x40
aab8: e5812028 str r2, [r1, #40] ; 0x28
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
aabc: e5902010 ldr r2, [r0, #16]
aac0: e5922034 ldr r2, [r2, #52] ; 0x34
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
aac4: e1d353b4 ldrh r5, [r3, #52] ; 0x34
* The device number of the IMFS is the major number and the minor is the
* instance.
*/
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
aac8: e592c000 ldr ip, [r2]
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
aacc: e59f207c ldr r2, [pc, #124] ; ab50 <IMFS_stat+0xf0>
fs_info = loc->mt_entry->fs_info;
buf->st_dev =
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
aad0: e1c151b0 strh r5, [r1, #16]
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
aad4: e5924000 ldr r4, [r2]
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
aad8: e3a02cff mov r2, #65280 ; 0xff00
aadc: e28220fe add r2, r2, #254 ; 0xfe
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
aae0: e5930044 ldr r0, [r3, #68] ; 0x44
/* * The device number of the IMFS is the major number and the minor is the * instance. */ fs_info = loc->mt_entry->fs_info; buf->st_dev =
aae4: e5812000 str r2, [r1]
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
aae8: e1d323bc ldrh r2, [r3, #60] ; 0x3c
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
aaec: e5810030 str r0, [r1, #48] ; 0x30
rtems_filesystem_make_dev_t( IMFS_DEVICE_MAJOR_NUMBER, fs_info->instance );
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
aaf0: e1c121b2 strh r2, [r1, #18]
buf->st_gid = the_jnode->st_gid;
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
aaf4: e5930048 ldr r0, [r3, #72] ; 0x48
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
aaf8: e1d333be ldrh r3, [r3, #62] ; 0x3e
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
aafc: e5810038 str r0, [r1, #56] ; 0x38
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
ab00: e5814040 str r4, [r1, #64] ; 0x40
/* * The device number of the IMFS is the major number and the minor is the * instance. */ fs_info = loc->mt_entry->fs_info; buf->st_dev =
ab04: e581c004 str ip, [r1, #4]
buf->st_mode = the_jnode->st_mode;
buf->st_nlink = the_jnode->st_nlink;
buf->st_ino = the_jnode->st_ino;
buf->st_uid = the_jnode->st_uid;
buf->st_gid = the_jnode->st_gid;
ab08: e1c131b4 strh r3, [r1, #20]
buf->st_atime = the_jnode->stat_atime;
buf->st_mtime = the_jnode->stat_mtime;
buf->st_ctime = the_jnode->stat_ctime;
buf->st_blksize = imfs_rq_memfile_bytes_per_block;
ab0c: e3a00000 mov r0, #0
return 0;
}
ab10: e8bd8030 pop {r4, r5, pc}
switch ( the_jnode->type ) {
case IMFS_DEVICE:
io = &the_jnode->info.device;
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
ab14: e2832050 add r2, r3, #80 ; 0x50
ab18: e8921004 ldm r2, {r2, ip}
ab1c: e581c01c str ip, [r1, #28]
ab20: e5812018 str r2, [r1, #24]
break;
ab24: eaffffde b aaa4 <IMFS_stat+0x44>
case IMFS_FIFO:
buf->st_size = 0;
break;
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
ab28: eb000de4 bl e2c0 <__errno> <== NOT EXECUTED
ab2c: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
ab30: e5803000 str r3, [r0] <== NOT EXECUTED
ab34: e3e00000 mvn r0, #0 <== NOT EXECUTED
ab38: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
buf->st_rdev = rtems_filesystem_make_dev_t( io->major, io->minor );
break;
case IMFS_LINEAR_FILE:
case IMFS_MEMORY_FILE:
buf->st_size = the_jnode->info.file.size;
ab3c: e2835050 add r5, r3, #80 ; 0x50
ab40: e8950030 ldm r5, {r4, r5}
ab44: e5814020 str r4, [r1, #32]
ab48: e5815024 str r5, [r1, #36] ; 0x24
break;
ab4c: eaffffd4 b aaa4 <IMFS_stat+0x44>
00001a00 <IMFS_symlink>:
int IMFS_symlink(
rtems_filesystem_location_info_t *parent_loc,
const char *link_name,
const char *node_name
)
{
1a00: e92d40f0 push {r4, r5, r6, r7, lr}
1a04: e1a06000 mov r6, r0
1a08: e24dd040 sub sp, sp, #64 ; 0x40
int i;
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( node_name, strlen( node_name ), new_name, &i );
1a0c: e1a00002 mov r0, r2
int IMFS_symlink(
rtems_filesystem_location_info_t *parent_loc,
const char *link_name,
const char *node_name
)
{
1a10: e1a07002 mov r7, r2
1a14: e1a05001 mov r5, r1
int i;
/*
* Remove any separators at the end of the string.
*/
IMFS_get_token( node_name, strlen( node_name ), new_name, &i );
1a18: eb00362d bl f2d4 <strlen>
1a1c: e28d4004 add r4, sp, #4
1a20: e1a01000 mov r1, r0
1a24: e1a02004 mov r2, r4
1a28: e28d303c add r3, sp, #60 ; 0x3c
1a2c: e1a00007 mov r0, r7
1a30: eb0023a8 bl a8d8 <IMFS_get_token>
/*
* Duplicate link name
*/
info.sym_link.name = strdup(link_name);
1a34: e1a00005 mov r0, r5
1a38: eb003611 bl f284 <strdup>
if (info.sym_link.name == NULL) {
1a3c: e3500000 cmp r0, #0
IMFS_get_token( node_name, strlen( node_name ), new_name, &i );
/*
* Duplicate link name
*/
info.sym_link.name = strdup(link_name);
1a40: e58d0028 str r0, [sp, #40] ; 0x28
if (info.sym_link.name == NULL) {
1a44: 0a00000e beq 1a84 <IMFS_symlink+0x84>
* was ONLY passed a NULL when we created the root node. We
* added a new IMFS_create_root_node() so this path no longer
* existed. The result was simpler code which should not have
* this path.
*/
new_node = IMFS_create_node(
1a48: e3a03ca2 mov r3, #41472 ; 0xa200
1a4c: e28dc028 add ip, sp, #40 ; 0x28
1a50: e1a00006 mov r0, r6
1a54: e1a02004 mov r2, r4
1a58: e2433001 sub r3, r3, #1
1a5c: e3a01004 mov r1, #4
1a60: e58dc000 str ip, [sp]
1a64: eb00201d bl 9ae0 <IMFS_create_node>
new_name,
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if (new_node == NULL) {
1a68: e3500000 cmp r0, #0
1a6c: 13a00000 movne r0, #0
1a70: 0a000001 beq 1a7c <IMFS_symlink+0x7c>
free(info.sym_link.name);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
return 0;
}
1a74: e28dd040 add sp, sp, #64 ; 0x40
1a78: e8bd80f0 pop {r4, r5, r6, r7, pc}
( S_IFLNK | ( S_IRWXU | S_IRWXG | S_IRWXO )),
&info
);
if (new_node == NULL) {
free(info.sym_link.name);
1a7c: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED
1a80: eb000188 bl 20a8 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
1a84: eb00320d bl e2c0 <__errno> <== NOT EXECUTED
1a88: e3a0300c mov r3, #12 <== NOT EXECUTED
1a8c: e5803000 str r3, [r0] <== NOT EXECUTED
1a90: e3e00000 mvn r0, #0 <== NOT EXECUTED
1a94: eafffff6 b 1a74 <IMFS_symlink+0x74> <== NOT EXECUTED
00001a98 <IMFS_unlink>:
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
1a98: e92d41f0 push {r4, r5, r6, r7, r8, lr}
IMFS_jnode_t *node;
rtems_filesystem_location_info_t the_link;
int result = 0;
node = loc->node_access;
1a9c: e5915000 ldr r5, [r1]
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
1aa0: e595304c ldr r3, [r5, #76] ; 0x4c
1aa4: e3530003 cmp r3, #3
int IMFS_unlink(
rtems_filesystem_location_info_t *parentloc, /* IN */
rtems_filesystem_location_info_t *loc /* IN */
)
{
1aa8: e24dd01c sub sp, sp, #28
1aac: e1a04001 mov r4, r1
1ab0: e1a06000 mov r6, r0
/*
* If this is the last last pointer to the node
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
1ab4: 0a000006 beq 1ad4 <IMFS_unlink+0x3c>
/*
* Now actually free the node we were asked to free.
*/
result = (*loc->handlers->rmnod_h)( parentloc, loc );
1ab8: e1a00006 mov r0, r6
1abc: e1a01004 mov r1, r4
1ac0: e5943008 ldr r3, [r4, #8]
1ac4: e1a0e00f mov lr, pc
1ac8: e593f034 ldr pc, [r3, #52] ; 0x34
return result;
}
1acc: e28dd01c add sp, sp, #28
1ad0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* free the node.
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
1ad4: e595e050 ldr lr, [r5, #80] ; 0x50
1ad8: e35e0000 cmp lr, #0
1adc: 0a00001f beq 1b60 <IMFS_unlink+0xc8>
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
1ae0: e1a07001 mov r7, r1
1ae4: e8b7000f ldm r7!, {r0, r1, r2, r3}
1ae8: e1a0c00d mov ip, sp
1aec: e8ac000f stmia ip!, {r0, r1, r2, r3}
the_link.node_access = node->info.hard_link.link_node;
1af0: e28d801c add r8, sp, #28
1af4: e528e01c str lr, [r8, #-28]!
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
1af8: e5973000 ldr r3, [r7]
the_link.node_access = node->info.hard_link.link_node;
IMFS_Set_handlers( &the_link );
1afc: e1a0000d mov r0, sp
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
the_link = *loc;
1b00: e58c3000 str r3, [ip]
the_link.node_access = node->info.hard_link.link_node;
IMFS_Set_handlers( &the_link );
1b04: eb002047 bl 9c28 <IMFS_Set_handlers>
/*
* If removing the last hard link to a node, then we need
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
1b08: e5953050 ldr r3, [r5, #80] ; 0x50
1b0c: e1d323b4 ldrh r2, [r3, #52] ; 0x34
1b10: e3520001 cmp r2, #1
1b14: 0a000008 beq 1b3c <IMFS_unlink+0xa4>
if ( result != 0 )
return -1;
}
else
{
node->info.hard_link.link_node->st_nlink --;
1b18: e2422001 sub r2, r2, #1
1b1c: e1c323b4 strh r2, [r3, #52] ; 0x34
IMFS_update_ctime( node->info.hard_link.link_node );
1b20: e28d0014 add r0, sp, #20
1b24: e3a01000 mov r1, #0
1b28: eb000187 bl 214c <gettimeofday>
1b2c: e5953050 ldr r3, [r5, #80] ; 0x50
1b30: e59d2014 ldr r2, [sp, #20]
1b34: e5832048 str r2, [r3, #72] ; 0x48
1b38: eaffffde b 1ab8 <IMFS_unlink+0x20>
* to remove the node that is a link and the node itself.
*/
if ( node->info.hard_link.link_node->st_nlink == 1)
{
result = (*the_link.handlers->rmnod_h)( parentloc, &the_link );
1b3c: e1a0100d mov r1, sp
1b40: e1a00006 mov r0, r6
1b44: e59d3008 ldr r3, [sp, #8]
1b48: e1a0e00f mov lr, pc
1b4c: e593f034 ldr pc, [r3, #52] ; 0x34
if ( result != 0 )
1b50: e3500000 cmp r0, #0
1b54: 13e00000 mvnne r0, #0
1b58: 0affffd6 beq 1ab8 <IMFS_unlink+0x20>
1b5c: eaffffda b 1acc <IMFS_unlink+0x34>
*/
if ( node->type == IMFS_HARD_LINK ) {
if ( !node->info.hard_link.link_node )
rtems_set_errno_and_return_minus_one( EINVAL );
1b60: eb0031d6 bl e2c0 <__errno> <== NOT EXECUTED
1b64: e3a03016 mov r3, #22 <== NOT EXECUTED
1b68: e5803000 str r3, [r0] <== NOT EXECUTED
1b6c: e3e00000 mvn r0, #0 <== NOT EXECUTED
1b70: eaffffd5 b 1acc <IMFS_unlink+0x34> <== NOT EXECUTED
00001b74 <IMFS_unmount>:
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
IMFS_jnode_t *node;
node = mt_entry->mt_point_node.node_access;
1b74: e5903008 ldr r3, [r0, #8]
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
1b78: e593204c ldr r2, [r3, #76] ; 0x4c
1b7c: e3520001 cmp r2, #1
#include <rtems/seterr.h>
int IMFS_unmount(
rtems_filesystem_mount_table_entry_t *mt_entry
)
{
1b80: e52de004 push {lr} ; (str lr, [sp, #-4]!)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
1b84: 1a000005 bne 1ba0 <IMFS_unmount+0x2c>
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
1b88: e593205c ldr r2, [r3, #92] ; 0x5c
1b8c: e3520000 cmp r2, #0
1b90: 0a000007 beq 1bb4 <IMFS_unmount+0x40>
/*
* Set the mt_fs pointer to indicate that there is no longer
* a file system mounted to this point.
*/
node->info.directory.mt_fs = NULL;
1b94: e3a00000 mov r0, #0
1b98: e583005c str r0, [r3, #92] ; 0x5c
return 0;
}
1b9c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
/*
* Is the node that we are mounting onto a directory node ?
*/
if ( node->type != IMFS_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
1ba0: eb0031c6 bl e2c0 <__errno> <== NOT EXECUTED
1ba4: e3a03014 mov r3, #20 <== NOT EXECUTED
1ba8: e5803000 str r3, [r0] <== NOT EXECUTED
1bac: e3e00000 mvn r0, #0 <== NOT EXECUTED
1bb0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* Did the node indicate that there was a directory mounted here?
*/
if ( node->info.directory.mt_fs == NULL )
rtems_set_errno_and_return_minus_one( EINVAL ); /* XXX */
1bb4: eb0031c1 bl e2c0 <__errno> <== NOT EXECUTED
1bb8: e3a03016 mov r3, #22 <== NOT EXECUTED
1bbc: e5803000 str r3, [r0] <== NOT EXECUTED
1bc0: e3e00000 mvn r0, #0 <== NOT EXECUTED
1bc4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0000231c <RTEMS_Malloc_Initialize>:
#endif
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
231c: e59f30d0 ldr r3, [pc, #208] ; 23f4 <RTEMS_Malloc_Initialize+0xd8>
2320: e5933000 ldr r3, [r3]
2324: e3530000 cmp r3, #0
void RTEMS_Malloc_Initialize(
void *heap_begin,
uintptr_t heap_size,
size_t sbrk_amount
)
{
2328: e92d4070 push {r4, r5, r6, lr}
232c: e1a05000 mov r5, r0
2330: e1a06001 mov r6, r1
2334: e1a04002 mov r4, r2
/*
* If configured, initialize the statistics support
*/
if ( rtems_malloc_statistics_helpers != NULL ) {
(*rtems_malloc_statistics_helpers->initialize)();
2338: 11a0e00f movne lr, pc
233c: 1593f000 ldrne pc, [r3]
}
/*
* Initialize the garbage collection list to start with nothing on it.
*/
malloc_deferred_frees_initialize();
2340: ebffffe1 bl 22cc <malloc_deferred_frees_initialize>
/*
* Initialize the optional sbrk support for extending the heap
*/
if ( rtems_malloc_sbrk_helpers != NULL ) {
2344: e59f30ac ldr r3, [pc, #172] ; 23f8 <RTEMS_Malloc_Initialize+0xdc>
2348: e5933000 ldr r3, [r3]
234c: e3530000 cmp r3, #0
2350: 0a000006 beq 2370 <RTEMS_Malloc_Initialize+0x54>
void *new_heap_begin = (*rtems_malloc_sbrk_helpers->initialize)(
2354: e1a00005 mov r0, r5 <== NOT EXECUTED
2358: e1a01004 mov r1, r4 <== NOT EXECUTED
235c: e1a0e00f mov lr, pc <== NOT EXECUTED
2360: e593f000 ldr pc, [r3] <== NOT EXECUTED
heap_begin,
sbrk_amount
);
heap_size -= (uintptr_t) new_heap_begin - (uintptr_t) heap_begin;
2364: e0856006 add r6, r5, r6 <== NOT EXECUTED
2368: e0606006 rsb r6, r0, r6 <== NOT EXECUTED
236c: e1a05000 mov r5, r0 <== NOT EXECUTED
* of the time under UNIX because zero'ing memory when it is first
* given to a process eliminates the chance of a process seeing data
* left over from another process. This would be a security violation.
*/
if (
2370: e59f4084 ldr r4, [pc, #132] ; 23fc <RTEMS_Malloc_Initialize+0xe0>
2374: e5d41000 ldrb r1, [r4]
2378: e3510000 cmp r1, #0
237c: 1a000018 bne 23e4 <RTEMS_Malloc_Initialize+0xc8>
!rtems_unified_work_area
&& rtems_configuration_get_do_zero_of_workspace()
2380: e59f3078 ldr r3, [pc, #120] ; 2400 <RTEMS_Malloc_Initialize+0xe4>
2384: e5d33028 ldrb r3, [r3, #40] ; 0x28
2388: e3530000 cmp r3, #0
238c: 1a00000e bne 23cc <RTEMS_Malloc_Initialize+0xb0>
void *area_begin,
uintptr_t area_size,
uintptr_t page_size
)
{
return _Heap_Initialize( heap, area_begin, area_size, page_size );
2390: e59f406c ldr r4, [pc, #108] ; 2404 <RTEMS_Malloc_Initialize+0xe8>
2394: e1a01005 mov r1, r5
2398: e1a02006 mov r2, r6
239c: e5940000 ldr r0, [r4]
23a0: e3a03004 mov r3, #4
23a4: eb0010a0 bl 662c <_Heap_Initialize>
RTEMS_Malloc_Heap,
heap_begin,
heap_size,
CPU_HEAP_ALIGNMENT
);
if ( status == 0 ) {
23a8: e3500000 cmp r0, #0
23ac: 0a00000e beq 23ec <RTEMS_Malloc_Initialize+0xd0>
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
}
MSBUMP( space_available, _Protected_heap_Get_size(RTEMS_Malloc_Heap) );
23b0: e59f5050 ldr r5, [pc, #80] ; 2408 <RTEMS_Malloc_Initialize+0xec>
23b4: e5940000 ldr r0, [r4]
23b8: e5954000 ldr r4, [r5]
23bc: eb0013a2 bl 724c <_Protected_heap_Get_size>
23c0: e0800004 add r0, r0, r4
23c4: e5850000 str r0, [r5]
printk( "\n" );
rtems_print_buffer( (heap_begin + heap_size) - 48, 48 );
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
}
#endif
}
23c8: e8bd8070 pop {r4, r5, r6, pc}
if (
!rtems_unified_work_area
&& rtems_configuration_get_do_zero_of_workspace()
) {
memset( heap_begin, 0, heap_size );
23cc: e1a00005 mov r0, r5
23d0: e1a02006 mov r2, r6
23d4: eb003203 bl ebe8 <memset>
* Unfortunately we cannot use assert if this fails because if this
* has failed we do not have a heap and if we do not have a heap
* STDIO cannot work because there will be no buffers.
*/
if ( !rtems_unified_work_area ) {
23d8: e5d43000 ldrb r3, [r4]
23dc: e3530000 cmp r3, #0
23e0: 0affffea beq 2390 <RTEMS_Malloc_Initialize+0x74>
23e4: e59f4018 ldr r4, [pc, #24] ; 2404 <RTEMS_Malloc_Initialize+0xe8>
23e8: eafffff0 b 23b0 <RTEMS_Malloc_Initialize+0x94>
heap_begin,
heap_size,
CPU_HEAP_ALIGNMENT
);
if ( status == 0 ) {
rtems_fatal_error_occurred( RTEMS_NO_MEMORY );
23ec: e280001a add r0, r0, #26 <== NOT EXECUTED
23f0: eb000e7a bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
000060f0 <Stack_check_Dump_threads_usage>:
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
60f0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
void *high_water_mark;
void *current;
Stack_Control *stack;
char name[5];
if ( !the_thread )
60f4: e250a000 subs sl, r0, #0 <== NOT EXECUTED
static rtems_printk_plugin_t print_handler;
void Stack_check_Dump_threads_usage(
Thread_Control *the_thread
)
{
60f8: e24dd010 sub sp, sp, #16 <== NOT EXECUTED
void *high_water_mark;
void *current;
Stack_Control *stack;
char name[5];
if ( !the_thread )
60fc: 0a000031 beq 61c8 <Stack_check_Dump_threads_usage+0xd8> <== NOT EXECUTED
return;
if ( !print_handler )
6100: e59f4110 ldr r4, [pc, #272] ; 6218 <Stack_check_Dump_threads_usage+0x128><== NOT EXECUTED
6104: e5947004 ldr r7, [r4, #4] <== NOT EXECUTED
6108: e3570000 cmp r7, #0 <== NOT EXECUTED
610c: 0a00002d beq 61c8 <Stack_check_Dump_threads_usage+0xd8> <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
if (the_thread == (Thread_Control *) -1) {
6110: e37a0001 cmn sl, #1 <== NOT EXECUTED
6114: 0a000032 beq 61e4 <Stack_check_Dump_threads_usage+0xf4> <== NOT EXECUTED
}
else
return;
} else {
stack = &the_thread->Start.Initial_stack;
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
6118: e59a80f0 ldr r8, [sl, #240] ; 0xf0 <== NOT EXECUTED
current = 0;
}
else
return;
} else {
stack = &the_thread->Start.Initial_stack;
611c: e28a50c0 add r5, sl, #192 ; 0xc0 <== NOT EXECUTED
current = (void *)_CPU_Context_Get_SP( &the_thread->Registers );
}
low = Stack_check_usable_stack_start(stack);
6120: e8950240 ldm r5, {r6, r9} <== NOT EXECUTED
6124: e2899010 add r9, r9, #16 <== NOT EXECUTED
size = Stack_check_usable_stack_size(stack);
6128: e2466010 sub r6, r6, #16 <== NOT EXECUTED
high_water_mark = Stack_check_find_high_water_mark(low, size);
612c: e1a00009 mov r0, r9 <== NOT EXECUTED
6130: e1a01006 mov r1, r6 <== NOT EXECUTED
6134: ebffffd7 bl 6098 <Stack_check_find_high_water_mark> <== NOT EXECUTED
if ( high_water_mark )
6138: e250b000 subs fp, r0, #0 <== NOT EXECUTED
used = Stack_check_Calculate_used( low, size, high_water_mark );
613c: 10899006 addne r9, r9, r6 <== NOT EXECUTED
6140: 106bb009 rsbne fp, fp, r9 <== NOT EXECUTED
else
used = 0;
if ( the_thread ) {
6144: e35a0000 cmp sl, #0 <== NOT EXECUTED
6148: 0a00002c beq 6200 <Stack_check_Dump_threads_usage+0x110> <== NOT EXECUTED
(*print_handler)(
614c: e59aa008 ldr sl, [sl, #8] <== NOT EXECUTED
6150: e28d2008 add r2, sp, #8 <== NOT EXECUTED
6154: e3a01005 mov r1, #5 <== NOT EXECUTED
6158: e1a0000a mov r0, sl <== NOT EXECUTED
615c: e5949008 ldr r9, [r4, #8] <== NOT EXECUTED
6160: eb001821 bl c1ec <rtems_object_get_name> <== NOT EXECUTED
6164: e1a0200a mov r2, sl <== NOT EXECUTED
6168: e1a03000 mov r3, r0 <== NOT EXECUTED
616c: e59f10a8 ldr r1, [pc, #168] ; 621c <Stack_check_Dump_threads_usage+0x12c><== NOT EXECUTED
6170: e1a00009 mov r0, r9 <== NOT EXECUTED
6174: e1a0e00f mov lr, pc <== NOT EXECUTED
6178: e12fff17 bx r7 <== NOT EXECUTED
);
} else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
(*print_handler)(
617c: e5953000 ldr r3, [r5] <== NOT EXECUTED
6180: e5952004 ldr r2, [r5, #4] <== NOT EXECUTED
6184: e2433001 sub r3, r3, #1 <== NOT EXECUTED
6188: e0823003 add r3, r2, r3 <== NOT EXECUTED
618c: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
6190: e58d8000 str r8, [sp] <== NOT EXECUTED
6194: e58d6004 str r6, [sp, #4] <== NOT EXECUTED
6198: e59f1080 ldr r1, [pc, #128] ; 6220 <Stack_check_Dump_threads_usage+0x130><== NOT EXECUTED
619c: e1a0e00f mov lr, pc <== NOT EXECUTED
61a0: e594f004 ldr pc, [r4, #4] <== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
61a4: e5943000 ldr r3, [r4] <== NOT EXECUTED
61a8: e3530000 cmp r3, #0 <== NOT EXECUTED
);
} else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
}
(*print_handler)(
61ac: e59f3064 ldr r3, [pc, #100] ; 6218 <Stack_check_Dump_threads_usage+0x128><== NOT EXECUTED
stack->area + stack->size - 1,
current,
size
);
if (Stack_check_Initialized == 0) {
61b0: 0a000006 beq 61d0 <Stack_check_Dump_threads_usage+0xe0> <== NOT EXECUTED
(*print_handler)( print_context, "Unavailable\n" );
} else {
(*print_handler)( print_context, "%8" PRId32 "\n", used );
61b4: e1a0200b mov r2, fp <== NOT EXECUTED
61b8: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
61bc: e59f1060 ldr r1, [pc, #96] ; 6224 <Stack_check_Dump_threads_usage+0x134><== NOT EXECUTED
61c0: e1a0e00f mov lr, pc <== NOT EXECUTED
61c4: e593f004 ldr pc, [r3, #4] <== NOT EXECUTED
}
}
61c8: e28dd010 add sp, sp, #16 <== NOT EXECUTED
61cc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
current,
size
);
if (Stack_check_Initialized == 0) {
(*print_handler)( print_context, "Unavailable\n" );
61d0: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
61d4: e59f104c ldr r1, [pc, #76] ; 6228 <Stack_check_Dump_threads_usage+0x138><== NOT EXECUTED
61d8: e1a0e00f mov lr, pc <== NOT EXECUTED
61dc: e593f004 ldr pc, [r3, #4] <== NOT EXECUTED
61e0: eafffff8 b 61c8 <Stack_check_Dump_threads_usage+0xd8> <== NOT EXECUTED
/*
* Obtain interrupt stack information
*/
if (the_thread == (Thread_Control *) -1) {
if (Stack_check_Interrupt_stack.area) {
61e4: e59f5040 ldr r5, [pc, #64] ; 622c <Stack_check_Dump_threads_usage+0x13c><== NOT EXECUTED
61e8: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED
61ec: e3530000 cmp r3, #0 <== NOT EXECUTED
61f0: 13a08000 movne r8, #0 <== NOT EXECUTED
61f4: 11a0a008 movne sl, r8 <== NOT EXECUTED
61f8: 1affffc8 bne 6120 <Stack_check_Dump_threads_usage+0x30> <== NOT EXECUTED
61fc: eafffff1 b 61c8 <Stack_check_Dump_threads_usage+0xd8> <== NOT EXECUTED
"0x%08" PRIx32 " %4s",
the_thread->Object.id,
rtems_object_get_name( the_thread->Object.id, sizeof(name), name )
);
} else {
(*print_handler)( print_context, "0x%08" PRIx32 " INTR", ~0 );
6200: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
6204: e59f1024 ldr r1, [pc, #36] ; 6230 <Stack_check_Dump_threads_usage+0x140><== NOT EXECUTED
6208: e3e02000 mvn r2, #0 <== NOT EXECUTED
620c: e1a0e00f mov lr, pc <== NOT EXECUTED
6210: e12fff17 bx r7 <== NOT EXECUTED
6214: eaffffd8 b 617c <Stack_check_Dump_threads_usage+0x8c> <== NOT EXECUTED
00006098 <Stack_check_find_high_water_mark>:
/*
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
6098: e2803010 add r3, r0, #16 <== NOT EXECUTED
for (ebase = base + length; base < ebase; base++)
609c: e3c11003 bic r1, r1, #3 <== NOT EXECUTED
60a0: e0831001 add r1, r3, r1 <== NOT EXECUTED
60a4: e1530001 cmp r3, r1 <== NOT EXECUTED
60a8: 2a00000c bcs 60e0 <Stack_check_find_high_water_mark+0x48> <== NOT EXECUTED
if (*base != U32_PATTERN)
60ac: e3a02ca6 mov r2, #42496 ; 0xa600 <== NOT EXECUTED
60b0: e242205b sub r2, r2, #91 ; 0x5b <== NOT EXECUTED
60b4: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
60b8: e1822802 orr r2, r2, r2, lsl #16 <== NOT EXECUTED
60bc: e1500002 cmp r0, r2 <== NOT EXECUTED
60c0: 0a000003 beq 60d4 <Stack_check_find_high_water_mark+0x3c> <== NOT EXECUTED
60c4: ea000007 b 60e8 <Stack_check_find_high_water_mark+0x50> <== NOT EXECUTED
60c8: e5932000 ldr r2, [r3] <== NOT EXECUTED
60cc: e1520000 cmp r2, r0 <== NOT EXECUTED
60d0: 1a000004 bne 60e8 <Stack_check_find_high_water_mark+0x50> <== NOT EXECUTED
* start at lower memory and find first word that does not
* match pattern
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
60d4: e2833004 add r3, r3, #4 <== NOT EXECUTED
60d8: e1510003 cmp r1, r3 <== NOT EXECUTED
60dc: 8afffff9 bhi 60c8 <Stack_check_find_high_water_mark+0x30> <== NOT EXECUTED
60e0: e3a00000 mov r0, #0 <== NOT EXECUTED
if (*base != U32_PATTERN)
return (void *) base;
#endif
return (void *)0;
}
60e4: e12fff1e bx lr <== NOT EXECUTED
*/
base += PATTERN_SIZE_WORDS;
for (ebase = base + length; base < ebase; base++)
if (*base != U32_PATTERN)
return (void *) base;
60e8: e1a00003 mov r0, r3 <== NOT EXECUTED
60ec: e12fff1e bx lr <== NOT EXECUTED
00042698 <T.57>:
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
42698: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
4269c: e3a06000 mov r6, #0 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
426a0: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 426a4: e58d1020 str r1, [sp, #32] <== NOT EXECUTED
rtems_rfs_bitmap_element* map_bits;
int map_index;
int map_offset;
int rc;
*found = false;
426a8: e5c26000 strb r6, [r2] <== NOT EXECUTED
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
426ac: e28d1024 add r1, sp, #36 ; 0x24 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
426b0: e58d201c str r2, [sp, #28] <== NOT EXECUTED 426b4: e1a04003 mov r4, r3 <== NOT EXECUTED 426b8: e58d0014 str r0, [sp, #20] <== NOT EXECUTED
*found = false;
/*
* Load the bitmap.
*/
rc = rtems_rfs_bitmap_load_map (control, &map);
426bc: ebfffeec bl 42274 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
426c0: e3500000 cmp r0, #0 <== NOT EXECUTED 426c4: da000001 ble 426d0 <T.57+0x38> <== NOT EXECUTED
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
return 0;
}
426c8: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
426cc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
return rc;
/*
* Calculate the bit we are testing plus the end point we search over.
*/
test_bit = *bit;
426d0: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED 426d4: e5910000 ldr r0, [r1] <== NOT EXECUTED
end_bit = test_bit + (window * direction);
if (end_bit < 0)
426d8: e0905584 adds r5, r0, r4, lsl #11 <== NOT EXECUTED 426dc: 41a05006 movmi r5, r6 <== NOT EXECUTED 426e0: 4a000003 bmi 426f4 <T.57+0x5c> <== NOT EXECUTED
end_bit = 0;
else if (end_bit >= control->size)
426e4: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 426e8: e592300c ldr r3, [r2, #12] <== NOT EXECUTED 426ec: e1550003 cmp r5, r3 <== NOT EXECUTED
end_bit = control->size - 1;
426f0: 22435001 subcs r5, r3, #1 <== NOT EXECUTED
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
426f4: e59dc014 ldr ip, [sp, #20] <== NOT EXECUTED 426f8: e59c3014 ldr r3, [ip, #20] <== NOT EXECUTED 426fc: e1a02540 asr r2, r0, #10 <== NOT EXECUTED 42700: e0833102 add r3, r3, r2, lsl #2 <== NOT EXECUTED
map_bits = &map[map_index];
42704: e59d9024 ldr r9, [sp, #36] ; 0x24 <== NOT EXECUTED
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
42708: e1a01104 lsl r1, r4, #2 <== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
4270c: e1a02fa4 lsr r2, r4, #31 <== NOT EXECUTED
if (end_bit < 0)
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
42710: e1a0a2c0 asr sl, r0, #5 <== NOT EXECUTED
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
42714: e58d1010 str r1, [sp, #16] <== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
42718: e58d200c str r2, [sp, #12] <== NOT EXECUTED
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
search_index = rtems_rfs_bitmap_map_index (map_index);
search_offset = rtems_rfs_bitmap_map_offset (map_index);
search_bits = &control->search_bits[search_index];
4271c: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
map_bits = &map[map_index];
42720: e089910a add r9, r9, sl, lsl #2 <== NOT EXECUTED
end_bit = 0;
else if (end_bit >= control->size)
end_bit = control->size - 1;
map_index = rtems_rfs_bitmap_map_index (test_bit);
map_offset = rtems_rfs_bitmap_map_offset (test_bit);
42724: e200301f and r3, r0, #31 <== NOT EXECUTED
search_index = rtems_rfs_bitmap_map_index (map_index); search_offset = rtems_rfs_bitmap_map_offset (map_index);
42728: e20a801f and r8, sl, #31 <== NOT EXECUTED
/*
* If any bit is clear find that bit and then search the map element. If
* all bits are set there are no map bits so move to the next search
* element.
*/
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
4272c: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED 42730: e59cc000 ldr ip, [ip] <== NOT EXECUTED 42734: e35c0000 cmp ip, #0 <== NOT EXECUTED 42738: e58dc000 str ip, [sp] <== NOT EXECUTED 4273c: 0a00003a beq 4282c <T.57+0x194> <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
42740: e1a01284 lsl r1, r4, #5 <== NOT EXECUTED 42744: e08ab004 add fp, sl, r4 <== NOT EXECUTED 42748: e58d1018 str r1, [sp, #24] <== NOT EXECUTED 4274c: e1a0b28b lsl fp, fp, #5 <== NOT EXECUTED
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
42750: e3a06001 mov r6, #1 <== NOT EXECUTED
* all bits are set there are no map bits so move to the next search
* element.
*/
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
{
while ((search_offset >= 0)
42754: e358001f cmp r8, #31 <== NOT EXECUTED 42758: 8a00003f bhi 4285c <T.57+0x1c4> <== NOT EXECUTED
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
4275c: e1a02816 lsl r2, r6, r8 <== NOT EXECUTED
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
{
while ((search_offset >= 0)
&& (search_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*search_bits, search_offset))
42760: e59dc000 ldr ip, [sp] <== NOT EXECUTED 42764: e112000c tst r2, ip <== NOT EXECUTED
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
42768: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
if (!rtems_rfs_bitmap_match (*search_bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
{
while ((search_offset >= 0)
&& (search_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*search_bits, search_offset))
4276c: 0a000013 beq 427c0 <T.57+0x128> <== NOT EXECUTED
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
42770: e1a01316 lsl r1, r6, r3 <== NOT EXECUTED
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
42774: e5997000 ldr r7, [r9] <== NOT EXECUTED 42778: e1110007 tst r1, r7 <== NOT EXECUTED 4277c: 1a00004a bne 428ac <T.57+0x214> <== NOT EXECUTED
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
if (test_bit == end_bit)
42780: e1550000 cmp r5, r0 <== NOT EXECUTED 42784: 10833004 addne r3, r3, r4 <== NOT EXECUTED 42788: 10802004 addne r2, r0, r4 <== NOT EXECUTED 4278c: 1a000009 bne 427b8 <T.57+0x120> <== NOT EXECUTED 42790: ea00000a b 427c0 <T.57+0x128> <== NOT EXECUTED
*/
static bool
rtems_rfs_bitmap_test (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_bit bit)
{
return RTEMS_RFS_BITMAP_TEST_BIT (target, bit);
42794: e1a01316 lsl r1, r6, r3 <== NOT EXECUTED
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
if (test_bit == end_bit)
42798: e1a00002 mov r0, r2 <== NOT EXECUTED
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
4279c: e1110007 tst r1, r7 <== NOT EXECUTED
*search_bits = rtems_rfs_bitmap_set (*search_bits,
1 << search_offset);
control->free--;
*bit = test_bit;
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
427a0: e0822004 add r2, r2, r4 <== NOT EXECUTED 427a4: e0833004 add r3, r3, r4 <== NOT EXECUTED
return 0;
}
if (test_bit == end_bit)
427a8: e064c002 rsb ip, r4, r2 <== NOT EXECUTED
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
427ac: 1a00003e bne 428ac <T.57+0x214> <== NOT EXECUTED
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
if (test_bit == end_bit)
427b0: e155000c cmp r5, ip <== NOT EXECUTED 427b4: 0a000001 beq 427c0 <T.57+0x128> <== NOT EXECUTED
{
/*
* Find the clear bit in the map. Update the search map and map if
* found. We may find none are spare if searching up from the seed.
*/
while ((map_offset >= 0)
427b8: e353001f cmp r3, #31 <== NOT EXECUTED 427bc: 9afffff4 bls 42794 <T.57+0xfc> <== NOT EXECUTED
}
}
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
427c0: e3540000 cmp r4, #0 <== NOT EXECUTED 427c4: d3a0001f movle r0, #31 <== NOT EXECUTED 427c8: c3a00000 movgt r0, #0 <== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
427cc: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
}
}
map_bits += direction;
map_index += direction;
map_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
427d0: d1a03000 movle r3, r0 <== NOT EXECUTED 427d4: c1a03000 movgt r3, r0 <== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
427d8: e08b0000 add r0, fp, r0 <== NOT EXECUTED
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
427dc: e1550000 cmp r5, r0 <== NOT EXECUTED 427e0: b3a02000 movlt r2, #0 <== NOT EXECUTED 427e4: a2022001 andge r2, r2, #1 <== NOT EXECUTED
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
427e8: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
427ec: e3520000 cmp r2, #0 <== NOT EXECUTED
map_offset += direction;
test_bit += direction;
}
}
map_bits += direction;
427f0: e0899001 add r9, r9, r1 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_search_map_for_clear_bit (rtems_rfs_bitmap_control* control,
427f4: e084a00a add sl, r4, sl <== NOT EXECUTED
test_bit = (map_index * rtems_rfs_bitmap_element_bits ()) + map_offset;
search_offset += direction;
if (((direction < 0) && (test_bit <= end_bit))
427f8: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 427fc: 1a00004c bne 42934 <T.57+0x29c> <== NOT EXECUTED 42800: e1550000 cmp r5, r0 <== NOT EXECUTED 42804: c3a01000 movgt r1, #0 <== NOT EXECUTED 42808: d3a01001 movle r1, #1 <== NOT EXECUTED 4280c: e3540000 cmp r4, #0 <== NOT EXECUTED 42810: d3a01000 movle r1, #0 <== NOT EXECUTED 42814: e59dc018 ldr ip, [sp, #24] <== NOT EXECUTED 42818: e3510000 cmp r1, #0 <== NOT EXECUTED 4281c: e08bb00c add fp, fp, ip <== NOT EXECUTED 42820: 1a000037 bne 42904 <T.57+0x26c> <== NOT EXECUTED 42824: e0848008 add r8, r4, r8 <== NOT EXECUTED 42828: eaffffc9 b 42754 <T.57+0xbc> <== NOT EXECUTED
* Align test_bit either up or down depending on the direction to next 32
* bit boundary.
*/
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
if (direction > 0)
4282c: e3540000 cmp r4, #0 <== NOT EXECUTED
bits_skipped = search_offset + 1;
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
42830: d1e03288 mvnle r3, r8, lsl #5 <== NOT EXECUTED
*/
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
if (direction > 0)
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
42834: c2688020 rsbgt r8, r8, #32 <== NOT EXECUTED
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
map_offset = 0;
}
else
{
bits_skipped = search_offset + 1;
42838: d2888001 addle r8, r8, #1 <== NOT EXECUTED
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
4283c: e0020894 mul r2, r4, r8 <== NOT EXECUTED
*
* Align test_bit either up or down depending on the direction to next 32
* bit boundary.
*/
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
42840: e3c0001f bic r0, r0, #31 <== NOT EXECUTED
if (direction > 0)
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
42844: c59d3000 ldrgt r3, [sp] <== NOT EXECUTED
bits_skipped = search_offset + 1;
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
42848: d0830000 addle r0, r3, r0 <== NOT EXECUTED
rtems_rfs_bitmap_bit bits_skipped;
test_bit &= ~((1 << RTEMS_RFS_ELEMENT_BITS_POWER_2) - 1);
if (direction > 0)
{
bits_skipped = rtems_rfs_bitmap_element_bits () - search_offset;
test_bit += bits_skipped * rtems_rfs_bitmap_element_bits ();
4284c: c0800288 addgt r0, r0, r8, lsl #5 <== NOT EXECUTED
bits_skipped = search_offset + 1;
/*
* Need to remove 1 for the rounding up. The above rounds down and
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
42850: d3a0301f movle r3, #31 <== NOT EXECUTED
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
42854: e08aa002 add sl, sl, r2 <== NOT EXECUTED
* adds 1. Remember the logic is for subtraction.
*/
test_bit -= ((bits_skipped - 1) * rtems_rfs_bitmap_element_bits ()) + 1;
map_offset = rtems_rfs_bitmap_element_bits () - 1;
}
map_bits += direction * bits_skipped;
42858: e0899102 add r9, r9, r2, lsl #2 <== NOT EXECUTED
map_index += direction * bits_skipped;
}
search_bits += direction;
4285c: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 42860: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
42864: e3540000 cmp r4, #0 <== NOT EXECUTED
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
42868: e0811002 add r1, r1, r2 <== NOT EXECUTED 4286c: e58d1008 str r1, [sp, #8] <== NOT EXECUTED
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
42870: da000029 ble 4291c <T.57+0x284> <== NOT EXECUTED 42874: e1550000 cmp r5, r0 <== NOT EXECUTED 42878: c3a01000 movgt r1, #0 <== NOT EXECUTED 4287c: d3a01001 movle r1, #1 <== NOT EXECUTED 42880: e3a02000 mov r2, #0 <== NOT EXECUTED 42884: e3a08000 mov r8, #0 <== NOT EXECUTED
}
while (((direction < 0) && (test_bit >= end_bit))
|| ((direction > 0) && (test_bit <= end_bit)));
42888: e1110002 tst r1, r2 <== NOT EXECUTED 4288c: 1affffa6 bne 4272c <T.57+0x94> <== NOT EXECUTED 42890: e1550000 cmp r5, r0 <== NOT EXECUTED 42894: a3540000 cmpge r4, #0 <== NOT EXECUTED 42898: d3a02000 movle r2, #0 <== NOT EXECUTED 4289c: c3a02001 movgt r2, #1 <== NOT EXECUTED 428a0: caffffa1 bgt 4272c <T.57+0x94> <== NOT EXECUTED 428a4: e1a00002 mov r0, r2 <== NOT EXECUTED 428a8: eaffff86 b 426c8 <T.57+0x30> <== NOT EXECUTED
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
428ac: e1c71001 bic r1, r7, r1 <== NOT EXECUTED
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
{
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
if (rtems_rfs_bitmap_match(*map_bits,
428b0: e3510000 cmp r1, #0 <== NOT EXECUTED
while ((map_offset >= 0)
&& (map_offset < rtems_rfs_bitmap_element_bits ()))
{
if (!rtems_rfs_bitmap_test (*map_bits, map_offset))
{
*map_bits = rtems_rfs_bitmap_set (*map_bits, 1 << map_offset);
428b4: e5891000 str r1, [r9] <== NOT EXECUTED
if (rtems_rfs_bitmap_match(*map_bits,
RTEMS_RFS_BITMAP_ELEMENT_SET))
*search_bits = rtems_rfs_bitmap_set (*search_bits,
428b8: 059d1008 ldreq r1, [sp, #8] <== NOT EXECUTED 428bc: 059d2004 ldreq r2, [sp, #4] <== NOT EXECUTED 428c0: 05913000 ldreq r3, [r1] <== NOT EXECUTED 428c4: 01c33002 biceq r3, r3, r2 <== NOT EXECUTED 428c8: 05813000 streq r3, [r1] <== NOT EXECUTED
1 << search_offset);
control->free--;
428cc: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 428d0: e5931010 ldr r1, [r3, #16] <== NOT EXECUTED 428d4: e59dc014 ldr ip, [sp, #20] <== NOT EXECUTED 428d8: e2411001 sub r1, r1, #1 <== NOT EXECUTED 428dc: e58c1010 str r1, [ip, #16] <== NOT EXECUTED
*bit = test_bit;
*found = true;
rtems_rfs_buffer_mark_dirty (control->buffer);
428e0: e5932000 ldr r2, [r3] <== NOT EXECUTED
if (rtems_rfs_bitmap_match(*map_bits,
RTEMS_RFS_BITMAP_ELEMENT_SET))
*search_bits = rtems_rfs_bitmap_set (*search_bits,
1 << search_offset);
control->free--;
*bit = test_bit;
428e4: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED
*found = true;
428e8: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED 428ec: e3a03001 mov r3, #1 <== NOT EXECUTED
if (rtems_rfs_bitmap_match(*map_bits,
RTEMS_RFS_BITMAP_ELEMENT_SET))
*search_bits = rtems_rfs_bitmap_set (*search_bits,
1 << search_offset);
control->free--;
*bit = test_bit;
428f0: e5810000 str r0, [r1] <== NOT EXECUTED
*found = true;
428f4: e5cc3000 strb r3, [ip] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
428f8: e3a00000 mov r0, #0 <== NOT EXECUTED 428fc: e5c23000 strb r3, [r2] <== NOT EXECUTED 42900: eaffff70 b 426c8 <T.57+0x30> <== NOT EXECUTED
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
42904: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED 42908: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 4290c: e08cc001 add ip, ip, r1 <== NOT EXECUTED 42910: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 42914: e3a01001 mov r1, #1 <== NOT EXECUTED 42918: eaffffd9 b 42884 <T.57+0x1ec> <== NOT EXECUTED
search_offset = direction > 0 ? 0 : rtems_rfs_bitmap_element_bits () - 1;
4291c: e1550000 cmp r5, r0 <== NOT EXECUTED 42920: c3a01000 movgt r1, #0 <== NOT EXECUTED 42924: d3a01001 movle r1, #1 <== NOT EXECUTED 42928: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 4292c: e3a0801f mov r8, #31 <== NOT EXECUTED 42930: eaffffd4 b 42888 <T.57+0x1f0> <== NOT EXECUTED
}
map_bits += direction * bits_skipped;
map_index += direction * bits_skipped;
}
search_bits += direction;
42934: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED 42938: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 4293c: e08cc001 add ip, ip, r1 <== NOT EXECUTED 42940: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 42944: e1550000 cmp r5, r0 <== NOT EXECUTED 42948: c3a01000 movgt r1, #0 <== NOT EXECUTED 4294c: d3a01001 movle r1, #1 <== NOT EXECUTED 42950: e3a02001 mov r2, #1 <== NOT EXECUTED 42954: e3a0801f mov r8, #31 <== NOT EXECUTED 42958: eaffffca b 42888 <T.57+0x1f0> <== NOT EXECUTED
00000454 <_Barrier_Manager_initialization>:
#include <rtems/score/object.h>
#include <rtems/rtems/barrier.h>
void _Barrier_Manager_initialization(void)
{
}
454: e12fff1e bx lr
0000b980 <_CORE_mutex_Seize_interrupt_trylock>:
{
Thread_Control *executing;
/* disabled when you get here */
executing = _Thread_Executing;
b980: e59f3138 ldr r3, [pc, #312] ; bac0 <_CORE_mutex_Seize_interrupt_trylock+0x140>
b984: e5933000 ldr r3, [r3]
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
b988: e3a02000 mov r2, #0
b98c: e5832034 str r2, [r3, #52] ; 0x34
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
b990: e590c050 ldr ip, [r0, #80] ; 0x50
b994: e15c0002 cmp ip, r2
#if defined(__RTEMS_DO_NOT_INLINE_CORE_MUTEX_SEIZE__)
int _CORE_mutex_Seize_interrupt_trylock(
CORE_mutex_Control *the_mutex,
ISR_Level *level_p
)
{
b998: e92d4070 push {r4, r5, r6, lr}
b99c: 0a00000e beq b9dc <_CORE_mutex_Seize_interrupt_trylock+0x5c>
the_mutex->lock = CORE_MUTEX_LOCKED;
b9a0: e5802050 str r2, [r0, #80] ; 0x50
*/
RTEMS_INLINE_ROUTINE bool _CORE_mutex_Is_inherit_priority(
CORE_mutex_Attributes *the_attribute
)
{
return the_attribute->discipline == CORE_MUTEX_DISCIPLINES_PRIORITY_INHERIT;
b9a4: e590c048 ldr ip, [r0, #72] ; 0x48
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
b9a8: e5935008 ldr r5, [r3, #8]
the_mutex->nest_count = 1;
b9ac: e3a04001 mov r4, #1
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
b9b0: e35c0002 cmp ip, #2
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
the_mutex->holder_id = executing->Object.id;
b9b4: e5805060 str r5, [r0, #96] ; 0x60
executing = _Thread_Executing;
executing->Wait.return_code = CORE_MUTEX_STATUS_SUCCESSFUL;
if ( !_CORE_mutex_Is_locked( the_mutex ) ) {
the_mutex->lock = CORE_MUTEX_LOCKED;
the_mutex->holder = executing;
b9b8: e580305c str r3, [r0, #92] ; 0x5c
the_mutex->holder_id = executing->Object.id;
the_mutex->nest_count = 1;
b9bc: e5804054 str r4, [r0, #84] ; 0x54
if ( _CORE_mutex_Is_inherit_priority( &the_mutex->Attributes ) ||
b9c0: 0a00000a beq b9f0 <_CORE_mutex_Seize_interrupt_trylock+0x70>
b9c4: e35c0003 cmp ip, #3
b9c8: 0a000019 beq ba34 <_CORE_mutex_Seize_interrupt_trylock+0xb4>
b9cc: e5913000 ldr r3, [r1]
b9d0: e129f003 msr CPSR_fc, r3
b9d4: e3a00000 mov r0, #0
b9d8: e8bd8070 pop {r4, r5, r6, pc}
/*
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
b9dc: e590205c ldr r2, [r0, #92] ; 0x5c
b9e0: e1530002 cmp r3, r2
b9e4: 0a000008 beq ba0c <_CORE_mutex_Seize_interrupt_trylock+0x8c>
b9e8: e3a00001 mov r0, #1
return _CORE_mutex_Seize_interrupt_trylock_body( the_mutex, level_p ); }
b9ec: e8bd8070 pop {r4, r5, r6, pc}
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
b9f0: e593201c ldr r2, [r3, #28]
b9f4: e2822001 add r2, r2, #1
b9f8: e583201c str r2, [r3, #28]
b9fc: e5913000 ldr r3, [r1]
ba00: e129f003 msr CPSR_fc, r3
ba04: e3a00000 mov r0, #0
ba08: e8bd8070 pop {r4, r5, r6, pc}
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
ba0c: e5902040 ldr r2, [r0, #64] ; 0x40
ba10: e3520000 cmp r2, #0
ba14: 1a000017 bne ba78 <_CORE_mutex_Seize_interrupt_trylock+0xf8>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
ba18: e5903054 ldr r3, [r0, #84] ; 0x54
ba1c: e2833001 add r3, r3, #1
ba20: e5803054 str r3, [r0, #84] ; 0x54
ba24: e5913000 ldr r3, [r1]
ba28: e129f003 msr CPSR_fc, r3
ba2c: e3a00000 mov r0, #0
ba30: e8bd8070 pop {r4, r5, r6, pc}
_Chain_Prepend_unprotected( &executing->lock_mutex,
&the_mutex->queue.lock_queue );
the_mutex->queue.priority_before = executing->current_priority;
#endif
executing->resource_count++;
ba34: e593c01c ldr ip, [r3, #28]
ba38: e08c5004 add r5, ip, r4
ba3c: e583501c str r5, [r3, #28]
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
current = executing->current_priority;
ba40: e5935014 ldr r5, [r3, #20]
*/
{
Priority_Control ceiling;
Priority_Control current;
ceiling = the_mutex->Attributes.priority_ceiling;
ba44: e590604c ldr r6, [r0, #76] ; 0x4c
current = executing->current_priority;
if ( current == ceiling ) {
ba48: e1560005 cmp r6, r5
ba4c: 0affffde beq b9cc <_CORE_mutex_Seize_interrupt_trylock+0x4c>
_ISR_Enable( *level_p );
return 0;
}
if ( current > ceiling ) {
ba50: 3a00000d bcc ba8c <_CORE_mutex_Seize_interrupt_trylock+0x10c>
);
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
ba54: e3a05006 mov r5, #6
ba58: e5835034 str r5, [r3, #52] ; 0x34
the_mutex->lock = CORE_MUTEX_UNLOCKED;
the_mutex->nest_count = 0; /* undo locking above */
ba5c: e5802054 str r2, [r0, #84] ; 0x54
_Thread_Enable_dispatch();
return 0;
}
/* if ( current < ceiling ) */ {
executing->Wait.return_code = CORE_MUTEX_STATUS_CEILING_VIOLATED;
the_mutex->lock = CORE_MUTEX_UNLOCKED;
ba60: e5804050 str r4, [r0, #80] ; 0x50
the_mutex->nest_count = 0; /* undo locking above */
executing->resource_count--; /* undo locking above */
ba64: e583c01c str ip, [r3, #28]
ba68: e5913000 ldr r3, [r1]
ba6c: e129f003 msr CPSR_fc, r3
ba70: e3a00000 mov r0, #0
ba74: e8bd8070 pop {r4, r5, r6, pc}
* At this point, we know the mutex was not available. If this thread
* is the thread that has locked the mutex, let's see if we are allowed
* to nest access.
*/
if ( _Thread_Is_executing( the_mutex->holder ) ) {
switch ( the_mutex->Attributes.lock_nesting_behavior ) {
ba78: e3520001 cmp r2, #1
ba7c: 1affffd9 bne b9e8 <_CORE_mutex_Seize_interrupt_trylock+0x68>
case CORE_MUTEX_NESTING_ACQUIRES:
the_mutex->nest_count++;
_ISR_Enable( *level_p );
return 0;
case CORE_MUTEX_NESTING_IS_ERROR:
executing->Wait.return_code = CORE_MUTEX_STATUS_NESTING_NOT_ALLOWED;
ba80: e3a02002 mov r2, #2 <== NOT EXECUTED
ba84: e5832034 str r2, [r3, #52] ; 0x34 <== NOT EXECUTED
ba88: eaffffcf b b9cc <_CORE_mutex_Seize_interrupt_trylock+0x4c> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
ba8c: e59f3030 ldr r3, [pc, #48] ; bac4 <_CORE_mutex_Seize_interrupt_trylock+0x144>
ba90: e5932000 ldr r2, [r3]
ba94: e2822001 add r2, r2, #1
ba98: e5832000 str r2, [r3]
ba9c: e5913000 ldr r3, [r1]
baa0: e129f003 msr CPSR_fc, r3
}
if ( current > ceiling ) {
_Thread_Disable_dispatch();
_ISR_Enable( *level_p );
_Thread_Change_priority(
baa4: e3a02000 mov r2, #0
baa8: e590104c ldr r1, [r0, #76] ; 0x4c
baac: e590005c ldr r0, [r0, #92] ; 0x5c
bab0: ebffedfb bl 72a4 <_Thread_Change_priority>
the_mutex->holder,
the_mutex->Attributes.priority_ceiling,
false
);
_Thread_Enable_dispatch();
bab4: ebffef65 bl 7850 <_Thread_Enable_dispatch>
bab8: e3a00000 mov r0, #0
babc: e8bd8070 pop {r4, r5, r6, pc}
00000458 <_Dual_ported_memory_Manager_initialization>:
#include <rtems/rtems/types.h>
#include <rtems/rtems/dpmem.h>
void _Dual_ported_memory_Manager_initialization(void)
{
}
458: e12fff1e bx lr
0000045c <_Event_Manager_initialization>:
#include <rtems/score/thread.h>
#include <rtems/score/interr.h>
void _Event_Manager_initialization(void)
{
}
45c: e12fff1e bx lr
00000478 <_Extension_Manager_initialization>:
#include <rtems/extension.h>
#include <rtems/score/interr.h>
void _Extension_Manager_initialization(void)
{
}
478: e12fff1e bx lr
0000bb3c <_Heap_Allocate_aligned_with_boundary>:
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
bb3c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
bb40: e1a08002 mov r8, r2
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
Heap_Block *block = _Heap_Free_list_first( heap );
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_BLOCK_SIZE_OFFSET;
uintptr_t const page_size = heap->page_size;
bb44: e5902010 ldr r2, [r0, #16]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
bb48: e24dd01c sub sp, sp, #28
bb4c: e1a05001 mov r5, r1
- HEAP_BLOCK_SIZE_OFFSET;
uintptr_t const page_size = heap->page_size;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
if ( block_size_floor < alloc_size ) {
bb50: e2911004 adds r1, r1, #4
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
bb54: e1a07000 mov r7, r0
- HEAP_BLOCK_SIZE_OFFSET;
uintptr_t const page_size = heap->page_size;
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
if ( block_size_floor < alloc_size ) {
bb58: e58d1000 str r1, [sp]
Heap_Control *heap,
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
bb5c: e1a0b003 mov fp, r3
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
bb60: e590a008 ldr sl, [r0, #8]
Heap_Statistics *const stats = &heap->stats;
Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
Heap_Block *block = _Heap_Free_list_first( heap );
uintptr_t const block_size_floor = alloc_size + HEAP_BLOCK_HEADER_SIZE
- HEAP_BLOCK_SIZE_OFFSET;
uintptr_t const page_size = heap->page_size;
bb64: e58d200c str r2, [sp, #12]
uintptr_t alloc_begin = 0;
uint32_t search_count = 0;
if ( block_size_floor < alloc_size ) {
bb68: 2a000076 bcs bd48 <_Heap_Allocate_aligned_with_boundary+0x20c>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
bb6c: e3530000 cmp r3, #0
bb70: 1a000072 bne bd40 <_Heap_Allocate_aligned_with_boundary+0x204>
if ( alignment == 0 ) {
alignment = page_size;
}
}
while ( block != free_list_tail ) {
bb74: e157000a cmp r7, sl
bb78: 03a06000 moveq r6, #0
bb7c: 0a000074 beq bd54 <_Heap_Allocate_aligned_with_boundary+0x218>
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
bb80: e59d300c ldr r3, [sp, #12]
uintptr_t alloc_end = block_end + HEAP_BLOCK_SIZE_OFFSET;
uintptr_t alloc_begin = alloc_end - alloc_size;
bb84: e2651004 rsb r1, r5, #4
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
bb88: e2833007 add r3, r3, #7
if ( alignment == 0 ) {
alignment = page_size;
}
}
while ( block != free_list_tail ) {
bb8c: e3a06000 mov r6, #0
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
bb90: e58d3010 str r3, [sp, #16]
uintptr_t alloc_end = block_end + HEAP_BLOCK_SIZE_OFFSET;
uintptr_t alloc_begin = alloc_end - alloc_size;
bb94: e58d1014 str r1, [sp, #20]
bb98: ea000004 b bbb0 <_Heap_Allocate_aligned_with_boundary+0x74>
boundary
);
}
}
if ( alloc_begin != 0 ) {
bb9c: e3540000 cmp r4, #0
bba0: 1a000059 bne bd0c <_Heap_Allocate_aligned_with_boundary+0x1d0>
break;
}
block = block->next;
bba4: e59aa008 ldr sl, [sl, #8]
if ( alignment == 0 ) {
alignment = page_size;
}
}
while ( block != free_list_tail ) {
bba8: e157000a cmp r7, sl
bbac: 0a000068 beq bd54 <_Heap_Allocate_aligned_with_boundary+0x218>
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
bbb0: e59a9004 ldr r9, [sl, #4]
bbb4: e59d2000 ldr r2, [sp]
bbb8: e1520009 cmp r2, r9
while ( block != free_list_tail ) {
_HAssert( _Heap_Is_prev_used( block ) );
/* Statistics */
++search_count;
bbbc: e2866001 add r6, r6, #1
/*
* The HEAP_PREV_BLOCK_USED flag is always set in the block size_and_flag
* field. Thus the value is about one unit larger than the real block
* size. The greater than operator takes this into account.
*/
if ( block->size_and_flag > block_size_floor ) {
bbc0: 2afffff7 bcs bba4 <_Heap_Allocate_aligned_with_boundary+0x68>
if ( alignment == 0 ) {
bbc4: e3580000 cmp r8, #0
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
bbc8: 028a4008 addeq r4, sl, #8
bbcc: 0afffff2 beq bb9c <_Heap_Allocate_aligned_with_boundary+0x60>
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
uintptr_t alloc_end = block_end + HEAP_BLOCK_SIZE_OFFSET;
uintptr_t alloc_begin = alloc_end - alloc_size;
bbd0: e59d1014 ldr r1, [sp, #20]
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
uintptr_t const block_begin = (uintptr_t) block;
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
bbd4: e3c99001 bic r9, r9, #1
bbd8: e08a9009 add r9, sl, r9
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
bbdc: e5973014 ldr r3, [r7, #20]
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
bbe0: e59d2010 ldr r2, [sp, #16]
uintptr_t alloc_end = block_end + HEAP_BLOCK_SIZE_OFFSET;
uintptr_t alloc_begin = alloc_end - alloc_size;
bbe4: e0814009 add r4, r1, r9
uintptr_t alignment,
uintptr_t boundary
)
{
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
bbe8: e58d3004 str r3, [sp, #4]
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
bbec: e1a00004 mov r0, r4
uintptr_t const block_size = _Heap_Block_size( block );
uintptr_t const block_end = block_begin + block_size;
uintptr_t const alloc_begin_floor = _Heap_Alloc_area_of_block( block );
uintptr_t const alloc_begin_ceiling = block_end - min_block_size
+ HEAP_BLOCK_HEADER_SIZE + page_size - 1;
bbf0: e0633002 rsb r3, r3, r2
bbf4: e1a01008 mov r1, r8
bbf8: e0839009 add r9, r3, r9
bbfc: eb002f7d bl 179f8 <__umodsi3>
bc00: e0604004 rsb r4, r0, r4
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Alloc_area_of_block(
const Heap_Block *block
)
{
return (uintptr_t) block + HEAP_BLOCK_HEADER_SIZE;
bc04: e28a3008 add r3, sl, #8
uintptr_t alloc_begin = alloc_end - alloc_size;
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
bc08: e1590004 cmp r9, r4
bc0c: e58d3008 str r3, [sp, #8]
bc10: 2a000003 bcs bc24 <_Heap_Allocate_aligned_with_boundary+0xe8>
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Align_down(
uintptr_t value,
uintptr_t alignment
)
{
return value - (value % alignment);
bc14: e1a00009 mov r0, r9
bc18: e1a01008 mov r1, r8
bc1c: eb002f75 bl 179f8 <__umodsi3>
bc20: e0604009 rsb r4, r0, r9
}
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
bc24: e35b0000 cmp fp, #0
bc28: 0a000025 beq bcc4 <_Heap_Allocate_aligned_with_boundary+0x188>
/* Ensure that the we have a valid new block at the end */
if ( alloc_begin > alloc_begin_ceiling ) {
alloc_begin = _Heap_Align_down( alloc_begin_ceiling, alignment );
}
alloc_end = alloc_begin + alloc_size;
bc2c: e0849005 add r9, r4, r5
bc30: e1a00009 mov r0, r9
bc34: e1a0100b mov r1, fp
bc38: eb002f6e bl 179f8 <__umodsi3>
bc3c: e0600009 rsb r0, r0, r9
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
bc40: e1590000 cmp r9, r0
bc44: 93a03000 movls r3, #0
bc48: 83a03001 movhi r3, #1
bc4c: e1540000 cmp r4, r0
bc50: 23a03000 movcs r3, #0
bc54: e3530000 cmp r3, #0
bc58: 0a000019 beq bcc4 <_Heap_Allocate_aligned_with_boundary+0x188>
alloc_end = alloc_begin + alloc_size;
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
bc5c: e59d1008 ldr r1, [sp, #8]
bc60: e0819005 add r9, r1, r5
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
if ( boundary_line < boundary_floor ) {
bc64: e1590000 cmp r9, r0
bc68: 958d6018 strls r6, [sp, #24]
bc6c: 9a000002 bls bc7c <_Heap_Allocate_aligned_with_boundary+0x140>
bc70: eaffffcb b bba4 <_Heap_Allocate_aligned_with_boundary+0x68>
bc74: e1590000 cmp r9, r0
bc78: 8a000037 bhi bd5c <_Heap_Allocate_aligned_with_boundary+0x220>
return 0;
}
alloc_begin = boundary_line - alloc_size;
bc7c: e0654000 rsb r4, r5, r0
bc80: e1a01008 mov r1, r8
bc84: e1a00004 mov r0, r4
bc88: eb002f5a bl 179f8 <__umodsi3>
bc8c: e0604004 rsb r4, r0, r4
alloc_begin = _Heap_Align_down( alloc_begin, alignment );
alloc_end = alloc_begin + alloc_size;
bc90: e0846005 add r6, r4, r5
bc94: e1a00006 mov r0, r6
bc98: e1a0100b mov r1, fp
bc9c: eb002f55 bl 179f8 <__umodsi3>
bca0: e0600006 rsb r0, r0, r6
/* Ensure boundary constaint */
if ( boundary != 0 ) {
uintptr_t const boundary_floor = alloc_begin_floor + alloc_size;
uintptr_t boundary_line = _Heap_Align_down( alloc_end, boundary );
while ( alloc_begin < boundary_line && boundary_line < alloc_end ) {
bca4: e1560000 cmp r6, r0
bca8: 93a03000 movls r3, #0
bcac: 83a03001 movhi r3, #1
bcb0: e1540000 cmp r4, r0
bcb4: 23a03000 movcs r3, #0
bcb8: e3530000 cmp r3, #0
bcbc: 1affffec bne bc74 <_Heap_Allocate_aligned_with_boundary+0x138>
bcc0: e59d6018 ldr r6, [sp, #24]
boundary_line = _Heap_Align_down( alloc_end, boundary );
}
}
/* Ensure that the we have a valid new block at the beginning */
if ( alloc_begin >= alloc_begin_floor ) {
bcc4: e59d2008 ldr r2, [sp, #8]
bcc8: e1520004 cmp r2, r4
bccc: 8affffb4 bhi bba4 <_Heap_Allocate_aligned_with_boundary+0x68>
uintptr_t const alloc_block_begin =
(uintptr_t) _Heap_Block_of_alloc_area( alloc_begin, page_size );
uintptr_t const free_size = alloc_block_begin - block_begin;
bcd0: e59d100c ldr r1, [sp, #12]
bcd4: e1a00004 mov r0, r4
bcd8: eb002f46 bl 179f8 <__umodsi3>
bcdc: e26a94ff rsb r9, sl, #-16777216 ; 0xff000000
bce0: e28998ff add r9, r9, #16711680 ; 0xff0000
bce4: e2899cff add r9, r9, #65280 ; 0xff00
bce8: e28990f8 add r9, r9, #248 ; 0xf8
bcec: e0899004 add r9, r9, r4
if ( free_size >= min_block_size || free_size == 0 ) {
bcf0: e59d1004 ldr r1, [sp, #4]
bcf4: e0603009 rsb r3, r0, r9
bcf8: e1590000 cmp r9, r0
bcfc: 11510003 cmpne r1, r3
bd00: 8affffa7 bhi bba4 <_Heap_Allocate_aligned_with_boundary+0x68>
boundary
);
}
}
if ( alloc_begin != 0 ) {
bd04: e3540000 cmp r4, #0
bd08: 0affffa5 beq bba4 <_Heap_Allocate_aligned_with_boundary+0x68>
block = block->next;
}
if ( alloc_begin != 0 ) {
/* Statistics */
stats->searches += search_count;
bd0c: e597304c ldr r3, [r7, #76] ; 0x4c
bd10: e0833006 add r3, r3, r6
bd14: e587304c str r3, [r7, #76] ; 0x4c
block = _Heap_Block_allocate( heap, block, alloc_begin, alloc_size );
bd18: e1a0100a mov r1, sl
bd1c: e1a03005 mov r3, r5
bd20: e1a00007 mov r0, r7
bd24: e1a02004 mov r2, r4
bd28: ebffead7 bl 688c <_Heap_Block_allocate>
bd2c: e1a00004 mov r0, r4
uintptr_t alloc_size,
uintptr_t alignment,
uintptr_t boundary
)
{
Heap_Statistics *const stats = &heap->stats;
bd30: e5973044 ldr r3, [r7, #68] ; 0x44
bd34: e1530006 cmp r3, r6
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
bd38: 35876044 strcc r6, [r7, #68] ; 0x44
bd3c: ea000002 b bd4c <_Heap_Allocate_aligned_with_boundary+0x210>
/* Integer overflow occured */
return NULL;
}
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
bd40: e1550003 cmp r5, r3
bd44: 9a000006 bls bd64 <_Heap_Allocate_aligned_with_boundary+0x228>
);
}
/* Statistics */
if ( stats->max_search < search_count ) {
stats->max_search = search_count;
bd48: e3a00000 mov r0, #0
}
return (void *) alloc_begin;
}
bd4c: e28dd01c add sp, sp, #28
bd50: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if ( alignment == 0 ) {
alignment = page_size;
}
}
while ( block != free_list_tail ) {
bd54: e3a00000 mov r0, #0
bd58: eafffff4 b bd30 <_Heap_Allocate_aligned_with_boundary+0x1f4>
bd5c: e59d6018 ldr r6, [sp, #24] <== NOT EXECUTED
bd60: eaffff8f b bba4 <_Heap_Allocate_aligned_with_boundary+0x68><== NOT EXECUTED
if ( boundary != 0 ) {
if ( boundary < alloc_size ) {
return NULL;
}
if ( alignment == 0 ) {
bd64: e3580000 cmp r8, #0
bd68: 01a08002 moveq r8, r2
bd6c: eaffff80 b bb74 <_Heap_Allocate_aligned_with_boundary+0x38>
0000763c <_Heap_Walk>:
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
763c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = heap->first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
7640: e59f35dc ldr r3, [pc, #1500] ; 7c24 <_Heap_Walk+0x5e8>
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = heap->first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
7644: e31200ff tst r2, #255 ; 0xff
if ( !_System_state_Is_up( _System_state_Get() ) ) {
7648: e5933000 ldr r3, [r3]
uintptr_t const page_size = heap->page_size;
uintptr_t const min_block_size = heap->min_block_size;
Heap_Block *const last_block = heap->last_block;
Heap_Block *block = heap->first_block;
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
764c: e59f25d4 ldr r2, [pc, #1492] ; 7c28 <_Heap_Walk+0x5ec>
7650: e59fa5d4 ldr sl, [pc, #1492] ; 7c2c <_Heap_Walk+0x5f0>
7654: 01a0a002 moveq sl, r2
if ( !_System_state_Is_up( _System_state_Get() ) ) {
7658: e3530003 cmp r3, #3
Heap_Control *heap,
int source,
bool dump
)
{
uintptr_t const page_size = heap->page_size;
765c: e5902010 ldr r2, [r0, #16]
uintptr_t const min_block_size = heap->min_block_size; Heap_Block *const last_block = heap->last_block;
7660: e5903024 ldr r3, [r0, #36] ; 0x24
bool _Heap_Walk(
Heap_Control *heap,
int source,
bool dump
)
{
7664: e24dd03c sub sp, sp, #60 ; 0x3c
7668: e1a04000 mov r4, r0
766c: e1a08001 mov r8, r1
uintptr_t const page_size = heap->page_size;
7670: e58d2020 str r2, [sp, #32]
uintptr_t const min_block_size = heap->min_block_size;
7674: e590b014 ldr fp, [r0, #20]
Heap_Block *const last_block = heap->last_block;
7678: e58d3024 str r3, [sp, #36] ; 0x24
Heap_Block *block = heap->first_block;
767c: e5905020 ldr r5, [r0, #32]
Heap_Walk_printer printer = dump ?
_Heap_Walk_print : _Heap_Walk_print_nothing;
if ( !_System_state_Is_up( _System_state_Get() ) ) {
7680: 0a000002 beq 7690 <_Heap_Walk+0x54>
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
}
while ( block != last_block ) {
7684: e3a00001 mov r0, #1
block = next_block;
}
return true;
}
7688: e28dd03c add sp, sp, #60 ; 0x3c
768c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
Heap_Block *const first_block = heap->first_block;
Heap_Block *const last_block = heap->last_block;
(*printer)(
7690: e5900018 ldr r0, [r0, #24]
7694: e594101c ldr r1, [r4, #28]
7698: e2842008 add r2, r4, #8
769c: e892000c ldm r2, {r2, r3}
76a0: e59dc024 ldr ip, [sp, #36] ; 0x24
76a4: e98d0003 stmib sp, {r0, r1}
76a8: e58d2014 str r2, [sp, #20]
76ac: e58d3018 str r3, [sp, #24]
76b0: e59f2578 ldr r2, [pc, #1400] ; 7c30 <_Heap_Walk+0x5f4>
76b4: e58db000 str fp, [sp]
76b8: e58d500c str r5, [sp, #12]
76bc: e58dc010 str ip, [sp, #16]
76c0: e1a00008 mov r0, r8
76c4: e3a01000 mov r1, #0
76c8: e59d3020 ldr r3, [sp, #32]
76cc: e1a0e00f mov lr, pc
76d0: e12fff1a bx sl
heap->area_begin, heap->area_end,
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
76d4: e59d2020 ldr r2, [sp, #32]
76d8: e3520000 cmp r2, #0
76dc: 0a000032 beq 77ac <_Heap_Walk+0x170>
(*printer)( source, true, "page size is zero\n" );
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
76e0: e59d3020 ldr r3, [sp, #32]
76e4: e2139003 ands r9, r3, #3
76e8: 1a000036 bne 77c8 <_Heap_Walk+0x18c>
);
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
76ec: e1a0000b mov r0, fp
76f0: e59d1020 ldr r1, [sp, #32]
76f4: ebffe547 bl c18 <__umodsi3>
76f8: e2506000 subs r6, r0, #0
76fc: 1a000038 bne 77e4 <_Heap_Walk+0x1a8>
);
return false;
}
if (
7700: e2850008 add r0, r5, #8
7704: e59d1020 ldr r1, [sp, #32]
7708: ebffe542 bl c18 <__umodsi3>
770c: e2509000 subs r9, r0, #0
7710: 1a00003b bne 7804 <_Heap_Walk+0x1c8>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
7714: e5957004 ldr r7, [r5, #4]
);
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
7718: e2176001 ands r6, r7, #1
771c: 0a000040 beq 7824 <_Heap_Walk+0x1e8>
);
return false;
}
if ( first_block->prev_size != page_size ) {
7720: e5953000 ldr r3, [r5]
7724: e59dc020 ldr ip, [sp, #32]
7728: e15c0003 cmp ip, r3
772c: 1a000016 bne 778c <_Heap_Walk+0x150>
);
return false;
}
if ( _Heap_Is_free( last_block ) ) {
7730: e59d2024 ldr r2, [sp, #36] ; 0x24
7734: e5923004 ldr r3, [r2, #4]
7738: e3c33001 bic r3, r3, #1
773c: e0823003 add r3, r2, r3
7740: e5939004 ldr r9, [r3, #4]
7744: e2199001 ands r9, r9, #1
7748: 0a000114 beq 7ba0 <_Heap_Walk+0x564>
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
774c: e5949008 ldr r9, [r4, #8]
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
7750: e5943010 ldr r3, [r4, #16]
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
7754: e1540009 cmp r4, r9
int source,
Heap_Walk_printer printer,
Heap_Control *heap
)
{
uintptr_t const page_size = heap->page_size;
7758: e58d3028 str r3, [sp, #40] ; 0x28
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
775c: 0a00006e beq 791c <_Heap_Walk+0x2e0>
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
7760: e5942020 ldr r2, [r4, #32]
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
7764: e1520009 cmp r2, r9
7768: 9a000034 bls 7840 <_Heap_Walk+0x204>
if ( !_Heap_Is_block_in_heap( heap, free_block ) ) {
(*printer)(
776c: e1a00008 mov r0, r8
7770: e1a03009 mov r3, r9
7774: e3a01001 mov r1, #1
7778: e59f24b4 ldr r2, [pc, #1204] ; 7c34 <_Heap_Walk+0x5f8>
777c: e1a0e00f mov lr, pc
7780: e12fff1a bx sl
7784: e3a00000 mov r0, #0
7788: eaffffbe b 7688 <_Heap_Walk+0x4c>
return false;
}
if ( first_block->prev_size != page_size ) {
(*printer)(
778c: e1a00008 mov r0, r8
7790: e58dc000 str ip, [sp]
7794: e3a01001 mov r1, #1
7798: e59f2498 ldr r2, [pc, #1176] ; 7c38 <_Heap_Walk+0x5fc>
779c: e1a0e00f mov lr, pc
77a0: e12fff1a bx sl
77a4: e1a00009 mov r0, r9
77a8: eaffffb6 b 7688 <_Heap_Walk+0x4c>
first_block, last_block,
first_free_block, last_free_block
);
if ( page_size == 0 ) {
(*printer)( source, true, "page size is zero\n" );
77ac: e1a00008 mov r0, r8
77b0: e3a01001 mov r1, #1
77b4: e59f2480 ldr r2, [pc, #1152] ; 7c3c <_Heap_Walk+0x600>
77b8: e1a0e00f mov lr, pc
77bc: e12fff1a bx sl
77c0: e59d0020 ldr r0, [sp, #32]
77c4: eaffffaf b 7688 <_Heap_Walk+0x4c>
return false;
}
if ( !_Addresses_Is_aligned( (void *) page_size ) ) {
(*printer)(
77c8: e1a00008 mov r0, r8
77cc: e3a01001 mov r1, #1
77d0: e59f2468 ldr r2, [pc, #1128] ; 7c40 <_Heap_Walk+0x604>
77d4: e1a0e00f mov lr, pc
77d8: e12fff1a bx sl
77dc: e3a00000 mov r0, #0
77e0: eaffffa8 b 7688 <_Heap_Walk+0x4c>
return false;
}
if ( !_Heap_Is_aligned( min_block_size, page_size ) ) {
(*printer)(
77e4: e1a00008 mov r0, r8
77e8: e1a0300b mov r3, fp
77ec: e3a01001 mov r1, #1
77f0: e59f244c ldr r2, [pc, #1100] ; 7c44 <_Heap_Walk+0x608>
77f4: e1a0e00f mov lr, pc
77f8: e12fff1a bx sl
77fc: e1a00009 mov r0, r9
7800: eaffffa0 b 7688 <_Heap_Walk+0x4c>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( first_block ), page_size )
) {
(*printer)(
7804: e1a00008 mov r0, r8
7808: e1a03005 mov r3, r5
780c: e3a01001 mov r1, #1
7810: e59f2430 ldr r2, [pc, #1072] ; 7c48 <_Heap_Walk+0x60c>
7814: e1a0e00f mov lr, pc
7818: e12fff1a bx sl
781c: e1a00006 mov r0, r6
7820: eaffff98 b 7688 <_Heap_Walk+0x4c>
return false;
}
if ( !_Heap_Is_prev_used( first_block ) ) {
(*printer)(
7824: e1a00008 mov r0, r8
7828: e3a01001 mov r1, #1
782c: e59f2418 ldr r2, [pc, #1048] ; 7c4c <_Heap_Walk+0x610>
7830: e1a0e00f mov lr, pc
7834: e12fff1a bx sl
7838: e1a00006 mov r0, r6
783c: eaffff91 b 7688 <_Heap_Walk+0x4c>
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
7840: e594c024 ldr ip, [r4, #36] ; 0x24
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
7844: e159000c cmp r9, ip
&& (uintptr_t) block <= (uintptr_t) heap->last_block;
7848: e58dc02c str ip, [sp, #44] ; 0x2c
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
784c: 8affffc6 bhi 776c <_Heap_Walk+0x130>
);
return false;
}
if (
7850: e2890008 add r0, r9, #8
7854: e1a01003 mov r1, r3
7858: e58d201c str r2, [sp, #28]
785c: ebffe4ed bl c18 <__umodsi3>
7860: e3500000 cmp r0, #0
7864: e59d201c ldr r2, [sp, #28]
7868: 1a0000d3 bne 7bbc <_Heap_Walk+0x580>
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
786c: e5993004 ldr r3, [r9, #4]
7870: e3c33001 bic r3, r3, #1
7874: e0893003 add r3, r9, r3
7878: e5933004 ldr r3, [r3, #4]
787c: e3130001 tst r3, #1
7880: 1a0000df bne 7c04 <_Heap_Walk+0x5c8>
);
return false;
}
if ( free_block->prev != prev_block ) {
7884: e599c00c ldr ip, [r9, #12]
7888: e15c0004 cmp ip, r4
788c: 1a0000d3 bne 7be0 <_Heap_Walk+0x5a4>
7890: e58d7030 str r7, [sp, #48] ; 0x30
7894: e58db034 str fp, [sp, #52] ; 0x34
7898: e59d702c ldr r7, [sp, #44] ; 0x2c
789c: e59db028 ldr fp, [sp, #40] ; 0x28
78a0: e58d502c str r5, [sp, #44] ; 0x2c
78a4: e58d6038 str r6, [sp, #56] ; 0x38
78a8: e1a0500c mov r5, ip
78ac: e58d4028 str r4, [sp, #40] ; 0x28
78b0: e1a06002 mov r6, r2
78b4: ea000011 b 7900 <_Heap_Walk+0x2c4>
78b8: e1560009 cmp r6, r9
78bc: 8affffaa bhi 776c <_Heap_Walk+0x130>
78c0: e1590007 cmp r9, r7
);
return false;
}
if (
78c4: e2890008 add r0, r9, #8
78c8: e1a0100b mov r1, fp
78cc: 8affffa6 bhi 776c <_Heap_Walk+0x130>
78d0: ebffe4d0 bl c18 <__umodsi3>
78d4: e3500000 cmp r0, #0
78d8: 1a0000b7 bne 7bbc <_Heap_Walk+0x580>
);
return false;
}
if ( _Heap_Is_used( free_block ) ) {
78dc: e5993004 ldr r3, [r9, #4]
78e0: e3c33001 bic r3, r3, #1
78e4: e0833009 add r3, r3, r9
78e8: e5933004 ldr r3, [r3, #4]
78ec: e3130001 tst r3, #1
78f0: 1a0000c3 bne 7c04 <_Heap_Walk+0x5c8>
);
return false;
}
if ( free_block->prev != prev_block ) {
78f4: e599200c ldr r2, [r9, #12]
78f8: e1540002 cmp r4, r2
78fc: 1a0000b6 bne 7bdc <_Heap_Walk+0x5a0>
(*printer)(
7900: e1a04009 mov r4, r9
return false;
}
prev_block = free_block;
free_block = free_block->next;
7904: e5999008 ldr r9, [r9, #8]
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
7908: e1550009 cmp r5, r9
790c: 1affffe9 bne 78b8 <_Heap_Walk+0x27c>
7910: e28d4028 add r4, sp, #40 ; 0x28
7914: e89408b0 ldm r4, {r4, r5, r7, fp}
7918: e59d6038 ldr r6, [sp, #56] ; 0x38
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
}
while ( block != last_block ) {
791c: e59d3024 ldr r3, [sp, #36] ; 0x24
7920: e1530005 cmp r3, r5
"block 0x%08x: prev 0x%08x%s, next 0x%08x%s\n",
block,
block->prev,
block->prev == first_free_block ?
" (= first)"
: (block->prev == free_list_head ? " (= head)" : ""),
7924: 158db028 strne fp, [sp, #40] ; 0x28
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
}
while ( block != last_block ) {
7928: 0affff55 beq 7684 <_Heap_Walk+0x48>
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
792c: e3c77001 bic r7, r7, #1
uintptr_t const block_size = _Heap_Block_size( block );
bool const prev_used = _Heap_Is_prev_used( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
uintptr_t const next_block_begin = (uintptr_t) next_block;
if ( prev_used ) {
7930: e21610ff ands r1, r6, #255 ; 0xff
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
7934: e0876005 add r6, r7, r5
7938: 0a000012 beq 7988 <_Heap_Walk+0x34c>
(*printer)(
793c: e1a03005 mov r3, r5
7940: e58d7000 str r7, [sp]
7944: e1a00008 mov r0, r8
7948: e3a01000 mov r1, #0
794c: e59f22fc ldr r2, [pc, #764] ; 7c50 <_Heap_Walk+0x614>
7950: e1a0e00f mov lr, pc
7954: e12fff1a bx sl
RTEMS_INLINE_ROUTINE bool _Heap_Is_block_in_heap(
const Heap_Control *heap,
const Heap_Block *block
)
{
return (uintptr_t) block >= (uintptr_t) heap->first_block
7958: e5943020 ldr r3, [r4, #32]
795c: e1530006 cmp r3, r6
7960: 9a000013 bls 79b4 <_Heap_Walk+0x378>
block->prev_size
);
}
if ( !_Heap_Is_block_in_heap( heap, next_block ) ) {
(*printer)(
7964: e1a00008 mov r0, r8
7968: e58d6000 str r6, [sp]
796c: e1a03005 mov r3, r5
7970: e3a01001 mov r1, #1
7974: e59f22d8 ldr r2, [pc, #728] ; 7c54 <_Heap_Walk+0x618>
7978: e1a0e00f mov lr, pc
797c: e12fff1a bx sl
7980: e3a00000 mov r0, #0
"block 0x%08x: next block 0x%08x not in heap\n",
block,
next_block
);
return false;
7984: eaffff3f b 7688 <_Heap_Walk+0x4c>
"block 0x%08x: size %u\n",
block,
block_size
);
} else {
(*printer)(
7988: e58d7000 str r7, [sp]
798c: e5953000 ldr r3, [r5]
7990: e1a00008 mov r0, r8
7994: e58d3004 str r3, [sp, #4]
7998: e59f22b8 ldr r2, [pc, #696] ; 7c58 <_Heap_Walk+0x61c>
799c: e1a03005 mov r3, r5
79a0: e1a0e00f mov lr, pc
79a4: e12fff1a bx sl
79a8: e5943020 ldr r3, [r4, #32]
79ac: e1530006 cmp r3, r6
79b0: 8affffeb bhi 7964 <_Heap_Walk+0x328>
79b4: e5943024 ldr r3, [r4, #36] ; 0x24
79b8: e1530006 cmp r3, r6
79bc: 3affffe8 bcc 7964 <_Heap_Walk+0x328>
);
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) ) {
79c0: e1a00007 mov r0, r7
79c4: e59d1020 ldr r1, [sp, #32]
79c8: ebffe492 bl c18 <__umodsi3>
79cc: e2509000 subs r9, r0, #0
79d0: 1a000055 bne 7b2c <_Heap_Walk+0x4f0>
);
return false;
}
if ( block_size < min_block_size ) {
79d4: e59d2028 ldr r2, [sp, #40] ; 0x28
79d8: e1520007 cmp r2, r7
79dc: 8a00005b bhi 7b50 <_Heap_Walk+0x514>
);
return false;
}
if ( next_block_begin <= block_begin ) {
79e0: e1550006 cmp r5, r6
79e4: 2a000064 bcs 7b7c <_Heap_Walk+0x540>
);
return false;
}
if ( !_Heap_Is_prev_used( next_block ) ) {
79e8: e5963004 ldr r3, [r6, #4]
79ec: e3130001 tst r3, #1
79f0: 1a000036 bne 7ad0 <_Heap_Walk+0x494>
block->size_and_flag = size | flag;
}
RTEMS_INLINE_ROUTINE bool _Heap_Is_prev_used( const Heap_Block *block )
{
return block->size_and_flag & HEAP_PREV_BLOCK_USED;
79f4: e595b004 ldr fp, [r5, #4]
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
79f8: e595200c ldr r2, [r5, #12]
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
79fc: e5943008 ldr r3, [r4, #8]
- HEAP_BLOCK_HEADER_SIZE);
}
RTEMS_INLINE_ROUTINE uintptr_t _Heap_Block_size( const Heap_Block *block )
{
return block->size_and_flag & ~HEAP_PREV_BLOCK_USED;
7a00: e3cb7001 bic r7, fp, #1
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
7a04: e1530002 cmp r3, r2
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_last( Heap_Control *heap )
{
return _Heap_Free_list_tail(heap)->prev;
7a08: e594100c ldr r1, [r4, #12]
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Block_at(
const Heap_Block *block,
uintptr_t offset
)
{
return (Heap_Block *) ((uintptr_t) block + offset);
7a0c: e0859007 add r9, r5, r7
return &heap->free_list;
}
RTEMS_INLINE_ROUTINE Heap_Block *_Heap_Free_list_first( Heap_Control *heap )
{
return _Heap_Free_list_head(heap)->next;
7a10: 059f0244 ldreq r0, [pc, #580] ; 7c5c <_Heap_Walk+0x620>
7a14: 0a000003 beq 7a28 <_Heap_Walk+0x3ec>
"block 0x%08x: prev 0x%08x%s, next 0x%08x%s\n",
block,
block->prev,
block->prev == first_free_block ?
" (= first)"
: (block->prev == free_list_head ? " (= head)" : ""),
7a18: e59f3240 ldr r3, [pc, #576] ; 7c60 <_Heap_Walk+0x624>
7a1c: e1520004 cmp r2, r4
7a20: e59f023c ldr r0, [pc, #572] ; 7c64 <_Heap_Walk+0x628>
7a24: 11a00003 movne r0, r3
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
7a28: e5953008 ldr r3, [r5, #8]
7a2c: e1510003 cmp r1, r3
7a30: 059f1230 ldreq r1, [pc, #560] ; 7c68 <_Heap_Walk+0x62c>
7a34: 0a000003 beq 7a48 <_Heap_Walk+0x40c>
" (= first)"
: (block->prev == free_list_head ? " (= head)" : ""),
block->next,
block->next == last_free_block ?
" (= last)"
: (block->next == free_list_tail ? " (= tail)" : "")
7a38: e59fc220 ldr ip, [pc, #544] ; 7c60 <_Heap_Walk+0x624>
7a3c: e1530004 cmp r3, r4
7a40: e59f1224 ldr r1, [pc, #548] ; 7c6c <_Heap_Walk+0x630>
7a44: 11a0100c movne r1, ip
Heap_Block *const last_free_block = _Heap_Free_list_last( heap );
bool const prev_used = _Heap_Is_prev_used( block );
uintptr_t const block_size = _Heap_Block_size( block );
Heap_Block *const next_block = _Heap_Block_at( block, block_size );
(*printer)(
7a48: e58d2000 str r2, [sp]
7a4c: e98d0009 stmib sp, {r0, r3}
7a50: e58d100c str r1, [sp, #12]
7a54: e1a03005 mov r3, r5
7a58: e1a00008 mov r0, r8
7a5c: e3a01000 mov r1, #0
7a60: e59f2208 ldr r2, [pc, #520] ; 7c70 <_Heap_Walk+0x634>
7a64: e1a0e00f mov lr, pc
7a68: e12fff1a bx sl
block->next == last_free_block ?
" (= last)"
: (block->next == free_list_tail ? " (= tail)" : "")
);
if ( block_size != next_block->prev_size ) {
7a6c: e5993000 ldr r3, [r9]
7a70: e1570003 cmp r7, r3
7a74: 0a00000a beq 7aa4 <_Heap_Walk+0x468>
(*printer)(
7a78: e58d3004 str r3, [sp, #4]
7a7c: e1a00008 mov r0, r8
7a80: e58d7000 str r7, [sp]
7a84: e58d9008 str r9, [sp, #8]
7a88: e1a03005 mov r3, r5
7a8c: e3a01001 mov r1, #1
7a90: e59f21dc ldr r2, [pc, #476] ; 7c74 <_Heap_Walk+0x638>
7a94: e1a0e00f mov lr, pc
7a98: e12fff1a bx sl
7a9c: e3a00000 mov r0, #0
7aa0: eafffef8 b 7688 <_Heap_Walk+0x4c>
);
return false;
}
if ( !prev_used ) {
7aa4: e21b9001 ands r9, fp, #1
7aa8: 0a000017 beq 7b0c <_Heap_Walk+0x4d0>
7aac: e5943008 ldr r3, [r4, #8]
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
7ab0: e1530004 cmp r3, r4
7ab4: 1a000003 bne 7ac8 <_Heap_Walk+0x48c>
7ab8: ea00000b b 7aec <_Heap_Walk+0x4b0> <== NOT EXECUTED
if ( free_block == block ) {
return true;
}
free_block = free_block->next;
7abc: e5933008 ldr r3, [r3, #8]
)
{
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *free_block = _Heap_Free_list_first( heap );
while ( free_block != free_list_tail ) {
7ac0: e1530004 cmp r3, r4
7ac4: 0a000008 beq 7aec <_Heap_Walk+0x4b0>
if ( free_block == block ) {
7ac8: e1530005 cmp r3, r5
7acc: 1afffffa bne 7abc <_Heap_Walk+0x480>
if ( !_Heap_Walk_check_control( source, printer, heap ) ) {
return false;
}
while ( block != last_block ) {
7ad0: e59d2024 ldr r2, [sp, #36] ; 0x24
7ad4: e1520006 cmp r2, r6
7ad8: 0afffee9 beq 7684 <_Heap_Walk+0x48>
const Heap_Block *const free_list_tail = _Heap_Free_list_tail( heap );
const Heap_Block *const first_free_block = _Heap_Free_list_first( heap );
const Heap_Block *prev_block = free_list_tail;
const Heap_Block *free_block = first_free_block;
while ( free_block != free_list_tail ) {
7adc: e5967004 ldr r7, [r6, #4]
7ae0: e1a05006 mov r5, r6
7ae4: e2076001 and r6, r7, #1
7ae8: eaffff8f b 792c <_Heap_Walk+0x2f0>
return false;
}
if ( !_Heap_Walk_is_in_free_list( heap, block ) ) {
(*printer)(
7aec: e1a00008 mov r0, r8
7af0: e1a03005 mov r3, r5
7af4: e3a01001 mov r1, #1
7af8: e59f2178 ldr r2, [pc, #376] ; 7c78 <_Heap_Walk+0x63c>
7afc: e1a0e00f mov lr, pc
7b00: e12fff1a bx sl
7b04: e3a00000 mov r0, #0
7b08: eafffede b 7688 <_Heap_Walk+0x4c>
return false;
}
if ( !prev_used ) {
(*printer)(
7b0c: e1a00008 mov r0, r8
7b10: e1a03005 mov r3, r5
7b14: e3a01001 mov r1, #1
7b18: e59f215c ldr r2, [pc, #348] ; 7c7c <_Heap_Walk+0x640>
7b1c: e1a0e00f mov lr, pc
7b20: e12fff1a bx sl
7b24: e1a00009 mov r0, r9
7b28: eafffed6 b 7688 <_Heap_Walk+0x4c>
return false;
}
if ( !_Heap_Is_aligned( block_size, page_size ) ) {
(*printer)(
7b2c: e1a00008 mov r0, r8
7b30: e58d7000 str r7, [sp]
7b34: e1a03005 mov r3, r5
7b38: e3a01001 mov r1, #1
7b3c: e59f213c ldr r2, [pc, #316] ; 7c80 <_Heap_Walk+0x644>
7b40: e1a0e00f mov lr, pc
7b44: e12fff1a bx sl
7b48: e3a00000 mov r0, #0
"block 0x%08x: block size %u not page aligned\n",
block,
block_size
);
return false;
7b4c: eafffecd b 7688 <_Heap_Walk+0x4c>
}
if ( block_size < min_block_size ) {
(*printer)(
7b50: e58d2004 str r2, [sp, #4]
7b54: e1a00008 mov r0, r8
7b58: e1a0b002 mov fp, r2
7b5c: e58d7000 str r7, [sp]
7b60: e1a03005 mov r3, r5
7b64: e3a01001 mov r1, #1
7b68: e59f2114 ldr r2, [pc, #276] ; 7c84 <_Heap_Walk+0x648>
7b6c: e1a0e00f mov lr, pc
7b70: e12fff1a bx sl
7b74: e1a00009 mov r0, r9
block,
block_size,
min_block_size
);
return false;
7b78: eafffec2 b 7688 <_Heap_Walk+0x4c>
}
if ( next_block_begin <= block_begin ) {
(*printer)(
7b7c: e1a00008 mov r0, r8
7b80: e58d6000 str r6, [sp]
7b84: e1a03005 mov r3, r5
7b88: e3a01001 mov r1, #1
7b8c: e59f20f4 ldr r2, [pc, #244] ; 7c88 <_Heap_Walk+0x64c>
7b90: e1a0e00f mov lr, pc
7b94: e12fff1a bx sl
7b98: e1a00009 mov r0, r9
"block 0x%08x: next block 0x%08x is not a successor\n",
block,
next_block
);
return false;
7b9c: eafffeb9 b 7688 <_Heap_Walk+0x4c>
return false;
}
if ( _Heap_Is_free( last_block ) ) {
(*printer)(
7ba0: e1a00008 mov r0, r8
7ba4: e3a01001 mov r1, #1
7ba8: e59f20dc ldr r2, [pc, #220] ; 7c8c <_Heap_Walk+0x650>
7bac: e1a0e00f mov lr, pc
7bb0: e12fff1a bx sl
7bb4: e1a00009 mov r0, r9
7bb8: eafffeb2 b 7688 <_Heap_Walk+0x4c>
}
if (
!_Heap_Is_aligned( _Heap_Alloc_area_of_block( free_block ), page_size )
) {
(*printer)(
7bbc: e1a00008 mov r0, r8
7bc0: e1a03009 mov r3, r9
7bc4: e3a01001 mov r1, #1
7bc8: e59f20c0 ldr r2, [pc, #192] ; 7c90 <_Heap_Walk+0x654>
7bcc: e1a0e00f mov lr, pc
7bd0: e12fff1a bx sl
7bd4: e3a00000 mov r0, #0
7bd8: eafffeaa b 7688 <_Heap_Walk+0x4c>
);
return false;
}
if ( free_block->prev != prev_block ) {
7bdc: e1a0c002 mov ip, r2
(*printer)(
7be0: e1a00008 mov r0, r8
7be4: e58dc000 str ip, [sp]
7be8: e1a03009 mov r3, r9
7bec: e3a01001 mov r1, #1
7bf0: e59f209c ldr r2, [pc, #156] ; 7c94 <_Heap_Walk+0x658>
7bf4: e1a0e00f mov lr, pc
7bf8: e12fff1a bx sl
7bfc: e3a00000 mov r0, #0
7c00: eafffea0 b 7688 <_Heap_Walk+0x4c>
return false;
}
if ( _Heap_Is_used( free_block ) ) {
(*printer)(
7c04: e1a00008 mov r0, r8
7c08: e1a03009 mov r3, r9
7c0c: e3a01001 mov r1, #1
7c10: e59f2080 ldr r2, [pc, #128] ; 7c98 <_Heap_Walk+0x65c>
7c14: e1a0e00f mov lr, pc
7c18: e12fff1a bx sl
7c1c: e3a00000 mov r0, #0
7c20: eafffe98 b 7688 <_Heap_Walk+0x4c>
00000460 <_Message_queue_Manager_initialization>:
#include <rtems/score/wkspace.h>
#include <rtems/score/interr.h>
void _Message_queue_Manager_initialization(void)
{
}
460: e12fff1e bx lr
00006afc <_Objects_Extend_information>:
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
6afc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
6b00: e5908034 ldr r8, [r0, #52] ; 0x34
6b04: e3580000 cmp r8, #0
*/
void _Objects_Extend_information(
Objects_Information *information
)
{
6b08: e24dd014 sub sp, sp, #20
6b0c: e1a05000 mov r5, r0
/*
* Search for a free block of indexes. The block variable ends up set
* to block_count + 1 if the table needs to be extended.
*/
minimum_index = _Objects_Get_index( information->minimum_id );
6b10: e1d070b8 ldrh r7, [r0, #8]
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
6b14: 0a00009c beq 6d8c <_Objects_Extend_information+0x290>
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
6b18: e1d091b4 ldrh r9, [r0, #20]
6b1c: e1d0a1b0 ldrh sl, [r0, #16]
6b20: e1a01009 mov r1, r9
6b24: e1a0000a mov r0, sl
6b28: eb00436e bl 178e8 <__aeabi_uidiv>
6b2c: e1a03800 lsl r3, r0, #16
for ( ; block < block_count; block++ ) {
6b30: e1b03823 lsrs r3, r3, #16
6b34: 01a01009 moveq r1, r9
6b38: 01a06007 moveq r6, r7
6b3c: 01a04003 moveq r4, r3
6b40: 0a00000f beq 6b84 <_Objects_Extend_information+0x88>
if ( information->object_blocks[ block ] == NULL )
6b44: e5984000 ldr r4, [r8]
6b48: e3540000 cmp r4, #0
6b4c: 11a01009 movne r1, r9
6b50: 11a06007 movne r6, r7
6b54: 13a04000 movne r4, #0
6b58: 01a01009 moveq r1, r9
6b5c: 01a06007 moveq r6, r7
6b60: 1a000003 bne 6b74 <_Objects_Extend_information+0x78>
6b64: ea000006 b 6b84 <_Objects_Extend_information+0x88> <== NOT EXECUTED
6b68: e7982104 ldr r2, [r8, r4, lsl #2]
6b6c: e3520000 cmp r2, #0
6b70: 0a000003 beq 6b84 <_Objects_Extend_information+0x88>
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
6b74: e2844001 add r4, r4, #1
6b78: e1530004 cmp r3, r4
if ( information->object_blocks[ block ] == NULL )
break;
else
index_base += information->allocation_size;
6b7c: e0866009 add r6, r6, r9
if ( information->object_blocks == NULL )
block_count = 0;
else {
block_count = information->maximum / information->allocation_size;
for ( ; block < block_count; block++ ) {
6b80: 8afffff8 bhi 6b68 <_Objects_Extend_information+0x6c>
else
index_base += information->allocation_size;
}
}
maximum = (uint32_t) information->maximum + information->allocation_size;
6b84: e08aa001 add sl, sl, r1
/*
* We need to limit the number of objects to the maximum number
* representable in the index portion of the object Id. In the
* case of 16-bit Ids, this is only 256 object instances.
*/
if ( maximum > OBJECTS_ID_FINAL_INDEX ) {
6b88: e35a0801 cmp sl, #65536 ; 0x10000
6b8c: 2a000064 bcs 6d24 <_Objects_Extend_information+0x228>
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
if ( information->auto_extend ) {
6b90: e5d50012 ldrb r0, [r5, #18]
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
6b94: e5952018 ldr r2, [r5, #24]
if ( information->auto_extend ) {
6b98: e3500000 cmp r0, #0
/*
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
6b9c: e0000192 mul r0, r2, r1
if ( information->auto_extend ) {
6ba0: 1a000061 bne 6d2c <_Objects_Extend_information+0x230>
new_object_block = _Workspace_Allocate( block_size );
if ( !new_object_block )
return;
} else {
new_object_block = _Workspace_Allocate_or_fatal_error( block_size );
6ba4: e58d3000 str r3, [sp]
6ba8: eb000809 bl 8bd4 <_Workspace_Allocate_or_fatal_error>
6bac: e59d3000 ldr r3, [sp]
6bb0: e1a09000 mov r9, r0
}
/*
* If the index_base is the maximum we need to grow the tables.
*/
if (index_base >= information->maximum ) {
6bb4: e1d521b0 ldrh r2, [r5, #16]
6bb8: e1560002 cmp r6, r2
6bbc: 3a000038 bcc 6ca4 <_Objects_Extend_information+0x1a8>
*/
/*
* Up the block count and maximum
*/
block_count++;
6bc0: e283c001 add ip, r3, #1
* Allocate the tables and break it up.
*/
block_size = block_count *
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
6bc4: e08c008c add r0, ip, ip, lsl #1
6bc8: e08a0000 add r0, sl, r0
6bcc: e0800007 add r0, r0, r7
6bd0: e1a00100 lsl r0, r0, #2
6bd4: e88d1008 stm sp, {r3, ip}
6bd8: eb000809 bl 8c04 <_Workspace_Allocate>
if ( !object_blocks ) {
6bdc: e250b000 subs fp, r0, #0
6be0: e89d1008 ldm sp, {r3, ip}
6be4: 0a00006e beq 6da4 <_Objects_Extend_information+0x2a8>
* Take the block count down. Saves all the (block_count - 1)
* in the copies.
*/
block_count--;
if ( information->maximum > minimum_index ) {
6be8: e1d521b0 ldrh r2, [r5, #16]
6bec: e1570002 cmp r7, r2
RTEMS_INLINE_ROUTINE void *_Addresses_Add_offset (
const void *base,
uintptr_t offset
)
{
return (void *)((uintptr_t)base + offset);
6bf0: e08b818c add r8, fp, ip, lsl #3
6bf4: e08bc10c add ip, fp, ip, lsl #2
6bf8: 3a000051 bcc 6d44 <_Objects_Extend_information+0x248>
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
6bfc: e3570000 cmp r7, #0
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
6c00: 13a02000 movne r2, #0
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
local_table[ index ] = NULL;
6c04: 11a01002 movne r1, r2
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
6c08: 0a000003 beq 6c1c <_Objects_Extend_information+0x120>
local_table[ index ] = NULL;
6c0c: e7881102 str r1, [r8, r2, lsl #2]
} else {
/*
* Deal with the special case of the 0 to minimum_index
*/
for ( index = 0; index < minimum_index; index++ ) {
6c10: e2822001 add r2, r2, #1
6c14: e1570002 cmp r7, r2
6c18: 8afffffb bhi 6c0c <_Objects_Extend_information+0x110>
6c1c: e1a03103 lsl r3, r3, #2
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
index < ( information->allocation_size + index_base );
6c20: e1d511b4 ldrh r1, [r5, #20]
6c24: e0861001 add r1, r6, r1
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
6c28: e3a00000 mov r0, #0
inactive_per_block[block_count] = 0;
for ( index=index_base ;
6c2c: e1560001 cmp r6, r1
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
6c30: e78c0003 str r0, [ip, r3]
}
/*
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
6c34: e78b0003 str r0, [fp, r3]
inactive_per_block[block_count] = 0;
for ( index=index_base ;
6c38: 2a000005 bcs 6c54 <_Objects_Extend_information+0x158>
6c3c: e0882106 add r2, r8, r6, lsl #2
6c40: e1a03006 mov r3, r6
index < ( information->allocation_size + index_base );
index++ ) {
6c44: e2833001 add r3, r3, #1
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
6c48: e1510003 cmp r1, r3
index < ( information->allocation_size + index_base );
index++ ) {
local_table[ index ] = NULL;
6c4c: e4820004 str r0, [r2], #4
* Initialise the new entries in the table.
*/
object_blocks[block_count] = NULL;
inactive_per_block[block_count] = 0;
for ( index=index_base ;
6c50: 8afffffb bhi 6c44 <_Objects_Extend_information+0x148>
6c54: e10f3000 mrs r3, CPSR
6c58: e3832080 orr r2, r3, #128 ; 0x80
6c5c: e129f002 msr CPSR_fc, r2
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
6c60: e5952000 ldr r2, [r5]
6c64: e1d510b4 ldrh r1, [r5, #4]
6c68: e1a02c02 lsl r2, r2, #24
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
6c6c: e1a0a80a lsl sl, sl, #16
information->maximum_id = _Objects_Build_id(
6c70: e3822801 orr r2, r2, #65536 ; 0x10000
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
6c74: e1a0a82a lsr sl, sl, #16
information->maximum_id = _Objects_Build_id(
6c78: e1822d81 orr r2, r2, r1, lsl #27
6c7c: e182200a orr r2, r2, sl
local_table[ index ] = NULL;
}
_ISR_Disable( level );
old_tables = information->object_blocks;
6c80: e5950034 ldr r0, [r5, #52] ; 0x34
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
6c84: e585c030 str ip, [r5, #48] ; 0x30
information->local_table = local_table;
6c88: e585801c str r8, [r5, #28]
information->maximum = (Objects_Maximum) maximum;
information->maximum_id = _Objects_Build_id(
6c8c: e585200c str r2, [r5, #12]
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
information->inactive_per_block = inactive_per_block;
information->local_table = local_table;
information->maximum = (Objects_Maximum) maximum;
6c90: e1c5a1b0 strh sl, [r5, #16]
_ISR_Disable( level );
old_tables = information->object_blocks;
information->object_blocks = object_blocks;
6c94: e585b034 str fp, [r5, #52] ; 0x34
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
6c98: e129f003 msr CPSR_fc, r3
information->maximum
);
_ISR_Enable( level );
if ( old_tables )
6c9c: e3500000 cmp r0, #0
_Workspace_Free( old_tables );
6ca0: 1b0007dd blne 8c1c <_Workspace_Free>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
6ca4: e5953034 ldr r3, [r5, #52] ; 0x34
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
6ca8: e28d7008 add r7, sp, #8
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
6cac: e7839104 str r9, [r3, r4, lsl #2]
/*
* Initialize objects .. add to a local chain first.
*/
_Chain_Initialize(
6cb0: e1a01009 mov r1, r9
6cb4: e1a00007 mov r0, r7
6cb8: e1d521b4 ldrh r2, [r5, #20]
6cbc: e5953018 ldr r3, [r5, #24]
6cc0: eb0012e7 bl b864 <_Chain_Initialize>
}
/*
* Assign the new object block to the object block table.
*/
information->object_blocks[ block ] = new_object_block;
6cc4: e1a04104 lsl r4, r4, #2
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
6cc8: e2858020 add r8, r5, #32
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
6ccc: ea000008 b 6cf4 <_Objects_Extend_information+0x1f8>
the_object->id = _Objects_Build_id(
6cd0: e5952000 ldr r2, [r5]
6cd4: e1d5c0b4 ldrh ip, [r5, #4]
6cd8: e1a02c02 lsl r2, r2, #24
6cdc: e3822801 orr r2, r2, #65536 ; 0x10000
6ce0: e1822d8c orr r2, r2, ip, lsl #27
6ce4: e1822006 orr r2, r2, r6
6ce8: e5832008 str r2, [r3, #8]
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
6cec: ebfffcf2 bl 60bc <_Chain_Append>
index++;
6cf0: e2866001 add r6, r6, #1
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
6cf4: e1a00007 mov r0, r7
6cf8: ebfffd03 bl 610c <_Chain_Get>
6cfc: e2503000 subs r3, r0, #0
information->the_class,
_Objects_Local_node,
index
);
_Chain_Append( &information->Inactive, &the_object->Node );
6d00: e1a01003 mov r1, r3
6d04: e1a00008 mov r0, r8
/*
* Move from the local chain, initialise, then append to the inactive chain
*/
index = index_base;
while ((the_object = (Objects_Control *) _Chain_Get( &Inactive )) != NULL ) {
6d08: 1afffff0 bne 6cd0 <_Objects_Extend_information+0x1d4>
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
6d0c: e1d531b4 ldrh r3, [r5, #20]
information->inactive =
6d10: e1d522bc ldrh r2, [r5, #44] ; 0x2c
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
6d14: e5951030 ldr r1, [r5, #48] ; 0x30
information->inactive =
6d18: e0832002 add r2, r3, r2
_Chain_Append( &information->Inactive, &the_object->Node );
index++;
}
information->inactive_per_block[ block ] = information->allocation_size;
6d1c: e7813004 str r3, [r1, r4]
information->inactive =
6d20: e1c522bc strh r2, [r5, #44] ; 0x2c
(Objects_Maximum)(information->inactive + information->allocation_size);
}
6d24: e28dd014 add sp, sp, #20
6d28: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* Allocate the name table, and the objects and if it fails either return or
* generate a fatal error depending on auto-extending being active.
*/
block_size = information->allocation_size * information->size;
if ( information->auto_extend ) {
new_object_block = _Workspace_Allocate( block_size );
6d2c: e58d3000 str r3, [sp]
6d30: eb0007b3 bl 8c04 <_Workspace_Allocate>
if ( !new_object_block )
6d34: e2509000 subs r9, r0, #0
6d38: e59d3000 ldr r3, [sp]
6d3c: 1affff9c bne 6bb4 <_Objects_Extend_information+0xb8>
6d40: eafffff7 b 6d24 <_Objects_Extend_information+0x228>
/*
* Copy each section of the table over. This has to be performed as
* separate parts as size of each block has changed.
*/
memcpy( object_blocks,
6d44: e1a03103 lsl r3, r3, #2
6d48: e1a02003 mov r2, r3
6d4c: e5951034 ldr r1, [r5, #52] ; 0x34
6d50: e88d1008 stm sp, {r3, ip}
6d54: eb001f67 bl eaf8 <memcpy>
information->object_blocks,
block_count * sizeof(void*) );
memcpy( inactive_per_block,
6d58: e89d1008 ldm sp, {r3, ip}
6d5c: e1a0000c mov r0, ip
6d60: e1a02003 mov r2, r3
6d64: e5951030 ldr r1, [r5, #48] ; 0x30
6d68: eb001f62 bl eaf8 <memcpy>
information->inactive_per_block,
block_count * sizeof(uint32_t) );
memcpy( local_table,
6d6c: e1d521b0 ldrh r2, [r5, #16]
6d70: e0872002 add r2, r7, r2
6d74: e1a02102 lsl r2, r2, #2
6d78: e1a00008 mov r0, r8
6d7c: e595101c ldr r1, [r5, #28]
6d80: eb001f5c bl eaf8 <memcpy>
6d84: e89d1008 ldm sp, {r3, ip}
6d88: eaffffa4 b 6c20 <_Objects_Extend_information+0x124>
minimum_index = _Objects_Get_index( information->minimum_id );
index_base = minimum_index;
block = 0;
/* if ( information->maximum < minimum_index ) */
if ( information->object_blocks == NULL )
6d8c: e1a04008 mov r4, r8
6d90: e1d0a1b0 ldrh sl, [r0, #16]
6d94: e1d011b4 ldrh r1, [r0, #20]
6d98: e1a06007 mov r6, r7
6d9c: e1a03008 mov r3, r8
6da0: eaffff77 b 6b84 <_Objects_Extend_information+0x88>
(sizeof(void *) + sizeof(uint32_t) + sizeof(Objects_Name *)) +
((maximum + minimum_index) * sizeof(Objects_Control *));
object_blocks = (void**) _Workspace_Allocate( block_size );
if ( !object_blocks ) {
_Workspace_Free( new_object_block );
6da4: e1a00009 mov r0, r9
6da8: eb00079b bl 8c1c <_Workspace_Free>
return;
6dac: eaffffdc b 6d24 <_Objects_Extend_information+0x228>
00000464 <_Partition_Manager_initialization>:
#include <rtems/score/thread.h>
#include <rtems/score/interr.h>
void _Partition_Manager_initialization(void)
{
}
464: e12fff1e bx lr
00000474 <_Rate_monotonic_Manager_initialization>:
#include <rtems/rtems/types.h>
#include <rtems/rtems/ratemon.h>
void _Rate_monotonic_Manager_initialization(void)
{
}
474: e12fff1e bx lr
00000468 <_Region_Manager_initialization>:
#include <rtems/score/thread.h>
#include <rtems/score/interr.h>
void _Region_Manager_initialization(void)
{
}
468: e12fff1e bx lr
00007dd4 <_Thread_queue_Enqueue_priority>:
Priority_Control priority;
States_Control block_state;
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
7dd4: e5913014 ldr r3, [r1, #20]
Thread_blocking_operation_States _Thread_queue_Enqueue_priority (
Thread_queue_Control *the_thread_queue,
Thread_Control *the_thread,
ISR_Level *level_p
)
{
7dd8: e92d05f0 push {r4, r5, r6, r7, r8, sl}
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
7ddc: e1a0c323 lsr ip, r3, #6
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
7de0: e281503c add r5, r1, #60 ; 0x3c
7de4: e08cc08c add ip, ip, ip, lsl #1
block_state = the_thread_queue->state;
if ( _Thread_queue_Is_reverse_search( priority ) )
7de8: e3130020 tst r3, #32
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
7dec: e2814038 add r4, r1, #56 ; 0x38
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
7df0: e5815038 str r5, [r1, #56] ; 0x38
the_chain->permanent_null = NULL;
7df4: e3a05000 mov r5, #0
7df8: e581503c str r5, [r1, #60] ; 0x3c
the_chain->last = _Chain_Head(the_chain);
7dfc: e5814040 str r4, [r1, #64] ; 0x40
_Chain_Initialize_empty( &the_thread->Wait.Block2n );
priority = the_thread->current_priority;
header_index = _Thread_queue_Header_number( priority );
header = &the_thread_queue->Queues.Priority[ header_index ];
7e00: e080c10c add ip, r0, ip, lsl #2
block_state = the_thread_queue->state;
7e04: e5906038 ldr r6, [r0, #56] ; 0x38
7e08: 159fa178 ldrne sl, [pc, #376] ; 7f88 <_Thread_queue_Enqueue_priority+0x1b4>
if ( _Thread_queue_Is_reverse_search( priority ) )
7e0c: 1a00001c bne 7e84 <_Thread_queue_Enqueue_priority+0xb0>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
7e10: e28ca004 add sl, ip, #4
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
7e14: e10f8000 mrs r8, CPSR
7e18: e3884080 orr r4, r8, #128 ; 0x80
7e1c: e129f004 msr CPSR_fc, r4
goto restart_reverse_search;
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
7e20: e59c4000 ldr r4, [ip]
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
7e24: e154000a cmp r4, sl
7e28: 1a000009 bne 7e54 <_Thread_queue_Enqueue_priority+0x80>
7e2c: ea000052 b 7f7c <_Thread_queue_Enqueue_priority+0x1a8>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
7e30: e10f7000 mrs r7, CPSR
7e34: e129f008 msr CPSR_fc, r8
7e38: e129f007 msr CPSR_fc, r7
search_priority = search_thread->current_priority;
if ( priority <= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
7e3c: e5947010 ldr r7, [r4, #16]
7e40: e1160007 tst r6, r7
7e44: 0a000033 beq 7f18 <_Thread_queue_Enqueue_priority+0x144>
_ISR_Enable( level );
goto restart_forward_search;
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
7e48: e5944000 ldr r4, [r4]
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
7e4c: e154000a cmp r4, sl
7e50: 0a000002 beq 7e60 <_Thread_queue_Enqueue_priority+0x8c>
search_priority = search_thread->current_priority;
7e54: e5945014 ldr r5, [r4, #20]
if ( priority <= search_priority )
7e58: e1530005 cmp r3, r5
7e5c: 8afffff3 bhi 7e30 <_Thread_queue_Enqueue_priority+0x5c>
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
7e60: e1a06008 mov r6, r8
}
search_thread =
(Thread_Control *)search_thread->Object.Node.next;
}
if ( the_thread_queue->sync_state !=
7e64: e590c030 ldr ip, [r0, #48] ; 0x30
7e68: e35c0001 cmp ip, #1
7e6c: 0a00002b beq 7f20 <_Thread_queue_Enqueue_priority+0x14c>
* For example, the blocking thread could have been given
* the mutex by an ISR or timed out.
*
* WARNING! Returning with interrupts disabled!
*/
*level_p = level;
7e70: e5826000 str r6, [r2]
return the_thread_queue->sync_state;
7e74: e1a0000c mov r0, ip
}
7e78: e8bd05f0 pop {r4, r5, r6, r7, r8, sl}
7e7c: e12fff1e bx lr
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
7e80: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
the_thread->Wait.queue = the_thread_queue;
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
7e84: e5da5000 ldrb r5, [sl]
7e88: e2855001 add r5, r5, #1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
7e8c: e10f8000 mrs r8, CPSR
7e90: e3884080 orr r4, r8, #128 ; 0x80
7e94: e129f004 msr CPSR_fc, r4
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
7e98: e59c4008 ldr r4, [ip, #8]
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
7e9c: e154000c cmp r4, ip
7ea0: 1a000009 bne 7ecc <_Thread_queue_Enqueue_priority+0xf8>
7ea4: ea00000b b 7ed8 <_Thread_queue_Enqueue_priority+0x104>
static inline void arm_interrupt_flash( uint32_t level )
{
uint32_t arm_switch_reg;
asm volatile (
7ea8: e10f7000 mrs r7, CPSR
7eac: e129f008 msr CPSR_fc, r8
7eb0: e129f007 msr CPSR_fc, r7
search_priority = search_thread->current_priority;
if ( priority >= search_priority )
break;
#endif
_ISR_Flash( level );
if ( !_States_Are_set( search_thread->current_state, block_state) ) {
7eb4: e5947010 ldr r7, [r4, #16]
7eb8: e1160007 tst r6, r7
7ebc: 0affffef beq 7e80 <_Thread_queue_Enqueue_priority+0xac>
_ISR_Enable( level );
goto restart_reverse_search;
}
search_thread = (Thread_Control *)
7ec0: e5944004 ldr r4, [r4, #4]
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
7ec4: e154000c cmp r4, ip
7ec8: 0a000002 beq 7ed8 <_Thread_queue_Enqueue_priority+0x104>
search_priority = search_thread->current_priority;
7ecc: e5945014 ldr r5, [r4, #20]
if ( priority >= search_priority )
7ed0: e1530005 cmp r3, r5
7ed4: 3afffff3 bcc 7ea8 <_Thread_queue_Enqueue_priority+0xd4>
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
7ed8: e590c030 ldr ip, [r0, #48] ; 0x30
7edc: e35c0001 cmp ip, #1
restart_reverse_search:
search_priority = PRIORITY_MAXIMUM + 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->last;
while ( !_Chain_Is_head( header, (Chain_Node *)search_thread ) ) {
7ee0: e1a06008 mov r6, r8
}
search_thread = (Thread_Control *)
search_thread->Object.Node.previous;
}
if ( the_thread_queue->sync_state !=
7ee4: 1affffe1 bne 7e70 <_Thread_queue_Enqueue_priority+0x9c>
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
7ee8: e1530005 cmp r3, r5
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
7eec: e3a03000 mov r3, #0
7ef0: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
7ef4: 0a000016 beq 7f54 <_Thread_queue_Enqueue_priority+0x180>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
next_node = search_node->next;
7ef8: e5943000 ldr r3, [r4]
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
7efc: e8810018 stm r1, {r3, r4}
search_node->next = the_node; next_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
7f00: e5810044 str r0, [r1, #68] ; 0x44
next_node = search_node->next;
the_node = (Chain_Node *) the_thread;
the_node->next = next_node;
the_node->previous = search_node;
search_node->next = the_node;
7f04: e5841000 str r1, [r4]
next_node->previous = the_node;
7f08: e5831004 str r1, [r3, #4]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
7f0c: e129f008 msr CPSR_fc, r8
7f10: e3a00001 mov r0, #1
the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
7f14: eaffffd7 b 7e78 <_Thread_queue_Enqueue_priority+0xa4>
7f18: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
7f1c: eaffffbc b 7e14 <_Thread_queue_Enqueue_priority+0x40> <== NOT EXECUTED
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
if ( priority == search_priority )
7f20: e1530005 cmp r3, r5
if ( the_thread_queue->sync_state !=
THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED )
goto synchronize;
the_thread_queue->sync_state = THREAD_BLOCKING_OPERATION_SYNCHRONIZED;
7f24: e3a03000 mov r3, #0
7f28: e5803030 str r3, [r0, #48] ; 0x30
if ( priority == search_priority )
7f2c: 0a000008 beq 7f54 <_Thread_queue_Enqueue_priority+0x180>
goto equal_priority;
search_node = (Chain_Node *) search_thread;
previous_node = search_node->previous;
7f30: e5943004 ldr r3, [r4, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
7f34: e5814000 str r4, [r1]
the_node->previous = previous_node;
7f38: e5813004 str r3, [r1, #4]
previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
7f3c: e5810044 str r0, [r1, #68] ; 0x44
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
previous_node->next = the_node;
7f40: e5831000 str r1, [r3]
search_node->previous = the_node;
7f44: e5841004 str r1, [r4, #4]
7f48: e129f008 msr CPSR_fc, r8
7f4c: e3a00001 mov r0, #1
the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
7f50: eaffffc8 b 7e78 <_Thread_queue_Enqueue_priority+0xa4>
7f54: e284403c add r4, r4, #60 ; 0x3c
_ISR_Enable( level );
return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
equal_priority: /* add at end of priority group */
search_node = _Chain_Tail( &search_thread->Wait.Block2n );
previous_node = search_node->previous;
7f58: e5943004 ldr r3, [r4, #4]
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
7f5c: e5814000 str r4, [r1]
the_node->previous = previous_node;
7f60: e5813004 str r3, [r1, #4]
previous_node->next = the_node; search_node->previous = the_node; the_thread->Wait.queue = the_thread_queue;
7f64: e5810044 str r0, [r1, #68] ; 0x44
previous_node = search_node->previous;
the_node = (Chain_Node *) the_thread;
the_node->next = search_node;
the_node->previous = previous_node;
previous_node->next = the_node;
7f68: e5831000 str r1, [r3]
search_node->previous = the_node;
7f6c: e5841004 str r1, [r4, #4]
7f70: e129f006 msr CPSR_fc, r6
7f74: e3a00001 mov r0, #1
the_thread->Wait.queue = the_thread_queue; _ISR_Enable( level ); return THREAD_BLOCKING_OPERATION_NOTHING_HAPPENED;
7f78: eaffffbe b 7e78 <_Thread_queue_Enqueue_priority+0xa4>
restart_forward_search:
search_priority = PRIORITY_MINIMUM - 1;
_ISR_Disable( level );
search_thread = (Thread_Control *) header->first;
while ( !_Chain_Is_tail( header, (Chain_Node *)search_thread ) ) {
7f7c: e1a06008 mov r6, r8
7f80: e3e05000 mvn r5, #0
7f84: eaffffb6 b 7e64 <_Thread_queue_Enqueue_priority+0x90>
00000470 <_Timer_Manager_initialization>:
#include <rtems/rtems/types.h>
#include <rtems/rtems/timer.h>
void _Timer_Manager_initialization(void)
{
}
470: e12fff1e bx lr
00016a3c <_Timer_server_Body>:
* @a arg points to the corresponding timer server control block.
*/
static rtems_task _Timer_server_Body(
rtems_task_argument arg
)
{
16a3c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
16a40: e24dd024 sub sp, sp, #36 ; 0x24
16a44: e28d700c add r7, sp, #12
16a48: e28d2018 add r2, sp, #24
16a4c: e1a04000 mov r4, r0
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
16a50: e3a03000 mov r3, #0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
16a54: e282a004 add sl, r2, #4 16a58: e2872004 add r2, r7, #4 16a5c: e58d2000 str r2, [sp]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
16a60: e58d301c str r3, [sp, #28]
the_chain->last = _Chain_Head(the_chain);
16a64: e28d0018 add r0, sp, #24
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
16a68: e58d200c str r2, [sp, #12]
the_chain->permanent_null = NULL;
16a6c: e58d3010 str r3, [sp, #16]
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
16a70: e2842008 add r2, r4, #8
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
16a74: e2843040 add r3, r4, #64 ; 0x40
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
16a78: e58da018 str sl, [sp, #24]
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
16a7c: e58d0020 str r0, [sp, #32] 16a80: e58d7014 str r7, [sp, #20] 16a84: e59f91a0 ldr r9, [pc, #416] ; 16c2c <_Timer_server_Body+0x1f0> 16a88: e59fb1a0 ldr fp, [pc, #416] ; 16c30 <_Timer_server_Body+0x1f4>
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
16a8c: e58d2008 str r2, [sp, #8]
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
16a90: e58d3004 str r3, [sp, #4]
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
16a94: e2846030 add r6, r4, #48 ; 0x30
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
16a98: e2848068 add r8, r4, #104 ; 0x68
{
/*
* Afterwards all timer inserts are directed to this chain and the interval
* and TOD chains will be no more modified by other parties.
*/
ts->insert_chain = insert_chain;
16a9c: e28d0018 add r0, sp, #24 16aa0: e5840078 str r0, [r4, #120] ; 0x78
static void _Timer_server_Process_interval_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = _Watchdog_Ticks_since_boot;
16aa4: e5993000 ldr r3, [r9]
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
16aa8: e594103c ldr r1, [r4, #60] ; 0x3c
watchdogs->last_snapshot = snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
16aac: e1a00006 mov r0, r6 16ab0: e0611003 rsb r1, r1, r3
/*
* We assume adequate unsigned arithmetic here.
*/
Watchdog_Interval delta = snapshot - watchdogs->last_snapshot;
watchdogs->last_snapshot = snapshot;
16ab4: e584303c str r3, [r4, #60] ; 0x3c
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
16ab8: e1a02007 mov r2, r7 16abc: eb00109c bl 1ad34 <_Watchdog_Adjust_to_chain>
static void _Timer_server_Process_tod_watchdogs(
Timer_server_Watchdogs *watchdogs,
Chain_Control *fire_chain
)
{
Watchdog_Interval snapshot = (Watchdog_Interval) _TOD_Seconds_since_epoch();
16ac0: e59b5000 ldr r5, [fp]
Watchdog_Interval last_snapshot = watchdogs->last_snapshot;
16ac4: e5941074 ldr r1, [r4, #116] ; 0x74
/*
* Process the seconds chain. Start by checking that the Time
* of Day (TOD) has not been set backwards. If it has then
* we want to adjust the watchdogs->Chain to indicate this.
*/
if ( snapshot > last_snapshot ) {
16ac8: e1550001 cmp r5, r1
16acc: 8a000022 bhi 16b5c <_Timer_server_Body+0x120>
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
} else if ( snapshot < last_snapshot ) {
16ad0: 3a000018 bcc 16b38 <_Timer_server_Body+0xfc>
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
}
watchdogs->last_snapshot = snapshot;
16ad4: e5845074 str r5, [r4, #116] ; 0x74
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
16ad8: e5940078 ldr r0, [r4, #120] ; 0x78 16adc: eb000240 bl 173e4 <_Chain_Get>
if ( timer == NULL ) {
16ae0: e3500000 cmp r0, #0
16ae4: 0a00000b beq 16b18 <_Timer_server_Body+0xdc>
static void _Timer_server_Insert_timer(
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
16ae8: e5903038 ldr r3, [r0, #56] ; 0x38 16aec: e3530001 cmp r3, #1
16af0: 0a000015 beq 16b4c <_Timer_server_Body+0x110>
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
} else if ( timer->the_class == TIMER_TIME_OF_DAY_ON_TASK ) {
16af4: e3530003 cmp r3, #3
16af8: 1afffff6 bne 16ad8 <_Timer_server_Body+0x9c>
_Watchdog_Insert( &ts->TOD_watchdogs.Chain, &timer->Ticker );
16afc: e2801010 add r1, r0, #16 16b00: e1a00008 mov r0, r8 16b04: eb0010b9 bl 1adf0 <_Watchdog_Insert>
}
static void _Timer_server_Process_insertions( Timer_server_Control *ts )
{
while ( true ) {
Timer_Control *timer = (Timer_Control *) _Chain_Get( ts->insert_chain );
16b08: e5940078 ldr r0, [r4, #120] ; 0x78 16b0c: eb000234 bl 173e4 <_Chain_Get>
if ( timer == NULL ) {
16b10: e3500000 cmp r0, #0
16b14: 1afffff3 bne 16ae8 <_Timer_server_Body+0xac>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
16b18: e10f2000 mrs r2, CPSR 16b1c: e3823080 orr r3, r2, #128 ; 0x80 16b20: e129f003 msr CPSR_fc, r3
* body loop.
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
16b24: e59d3018 ldr r3, [sp, #24] 16b28: e15a0003 cmp sl, r3
16b2c: 0a00000f beq 16b70 <_Timer_server_Body+0x134>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
16b30: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED 16b34: eaffffda b 16aa4 <_Timer_server_Body+0x68> <== NOT EXECUTED
/*
* The current TOD is before the last TOD which indicates that
* TOD has been set backwards.
*/
delta = last_snapshot - snapshot;
_Watchdog_Adjust( &watchdogs->Chain, WATCHDOG_BACKWARD, delta );
16b38: e0652001 rsb r2, r5, r1 16b3c: e1a00008 mov r0, r8 16b40: e3a01001 mov r1, #1 16b44: eb00104b bl 1ac78 <_Watchdog_Adjust> 16b48: eaffffe1 b 16ad4 <_Timer_server_Body+0x98>
Timer_server_Control *ts,
Timer_Control *timer
)
{
if ( timer->the_class == TIMER_INTERVAL_ON_TASK ) {
_Watchdog_Insert( &ts->Interval_watchdogs.Chain, &timer->Ticker );
16b4c: e2801010 add r1, r0, #16 16b50: e1a00006 mov r0, r6 16b54: eb0010a5 bl 1adf0 <_Watchdog_Insert> 16b58: eaffffde b 16ad8 <_Timer_server_Body+0x9c>
/*
* This path is for normal forward movement and cases where the
* TOD has been set forward.
*/
delta = snapshot - last_snapshot;
_Watchdog_Adjust_to_chain( &watchdogs->Chain, delta, fire_chain );
16b5c: e0611005 rsb r1, r1, r5 16b60: e1a00008 mov r0, r8 16b64: e1a02007 mov r2, r7 16b68: eb001071 bl 1ad34 <_Watchdog_Adjust_to_chain> 16b6c: eaffffd8 b 16ad4 <_Timer_server_Body+0x98>
*/
_Timer_server_Process_insertions( ts );
_ISR_Disable( level );
if ( _Chain_Is_empty( insert_chain ) ) {
ts->insert_chain = NULL;
16b70: e5840078 str r0, [r4, #120] ; 0x78 16b74: e129f002 msr CPSR_fc, r2
_Chain_Initialize_empty( &fire_chain );
while ( true ) {
_Timer_server_Get_watchdogs_that_fire_now( ts, &insert_chain, &fire_chain );
if ( !_Chain_Is_empty( &fire_chain ) ) {
16b78: e59d300c ldr r3, [sp, #12] 16b7c: e59d2000 ldr r2, [sp] 16b80: e1520003 cmp r2, r3 16b84: 159d5000 ldrne r5, [sp]
16b88: 1a00000a bne 16bb8 <_Timer_server_Body+0x17c>
16b8c: ea000011 b 16bd8 <_Timer_server_Body+0x19c>
{
Chain_Node *return_node;
Chain_Node *new_first;
return_node = the_chain->first;
new_first = return_node->next;
16b90: e5932000 ldr r2, [r3]
* service routine may remove a watchdog from the chain.
*/
_ISR_Disable( level );
watchdog = (Watchdog_Control *) _Chain_Get_unprotected( &fire_chain );
if ( watchdog != NULL ) {
watchdog->state = WATCHDOG_INACTIVE;
16b94: e3a00000 mov r0, #0
the_chain->first = new_first;
16b98: e58d200c str r2, [sp, #12] 16b9c: e5830008 str r0, [r3, #8]
new_first->previous = _Chain_Head(the_chain);
16ba0: e5827004 str r7, [r2, #4] 16ba4: e129f001 msr CPSR_fc, r1
/*
* The timer server may block here and wait for resources or time.
* The system watchdogs are inactive and will remain inactive since
* the active flag of the timer server is true.
*/
(*watchdog->routine)( watchdog->id, watchdog->user_data );
16ba8: e2830020 add r0, r3, #32
16bac: e8900003 ldm r0, {r0, r1}
16bb0: e1a0e00f mov lr, pc
16bb4: e593f01c ldr pc, [r3, #28]
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
16bb8: e10f1000 mrs r1, CPSR 16bbc: e3813080 orr r3, r1, #128 ; 0x80 16bc0: e129f003 msr CPSR_fc, r3
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
16bc4: e59d300c ldr r3, [sp, #12]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Get_unprotected(
Chain_Control *the_chain
)
{
if ( !_Chain_Is_empty(the_chain))
16bc8: e1550003 cmp r5, r3
16bcc: 1affffef bne 16b90 <_Timer_server_Body+0x154>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
16bd0: e129f001 msr CPSR_fc, r1 16bd4: eaffffb0 b 16a9c <_Timer_server_Body+0x60>
}
} else {
ts->active = false;
16bd8: e3a02000 mov r2, #0 16bdc: e5c4207c strb r2, [r4, #124] ; 0x7c 16be0: e59f004c ldr r0, [pc, #76] ; 16c34 <_Timer_server_Body+0x1f8> 16be4: e5903000 ldr r3, [r0] 16be8: e2833001 add r3, r3, #1 16bec: e5803000 str r3, [r0]
/*
* Block until there is something to do.
*/
_Thread_Disable_dispatch();
_Thread_Set_state( ts->thread, STATES_DELAYING );
16bf0: e3a01008 mov r1, #8 16bf4: e5940000 ldr r0, [r4] 16bf8: eb000db2 bl 1a2c8 <_Thread_Set_state>
_Timer_server_Reset_interval_system_watchdog( ts );
16bfc: e1a00004 mov r0, r4 16c00: ebffff61 bl 1698c <_Timer_server_Reset_interval_system_watchdog>
_Timer_server_Reset_tod_system_watchdog( ts );
16c04: e1a00004 mov r0, r4 16c08: ebffff75 bl 169e4 <_Timer_server_Reset_tod_system_watchdog>
_Thread_Enable_dispatch();
16c0c: eb000aff bl 19810 <_Thread_Enable_dispatch>
ts->active = true;
16c10: e3a02001 mov r2, #1 16c14: e5c4207c strb r2, [r4, #124] ; 0x7c
static void _Timer_server_Stop_interval_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->Interval_watchdogs.System_watchdog );
16c18: e59d0008 ldr r0, [sp, #8] 16c1c: eb0010d4 bl 1af74 <_Watchdog_Remove>
static void _Timer_server_Stop_tod_system_watchdog(
Timer_server_Control *ts
)
{
_Watchdog_Remove( &ts->TOD_watchdogs.System_watchdog );
16c20: e59d0004 ldr r0, [sp, #4] 16c24: eb0010d2 bl 1af74 <_Watchdog_Remove> 16c28: eaffff9b b 16a9c <_Timer_server_Body+0x60>
0000a858 <_Watchdog_Adjust>:
void _Watchdog_Adjust(
Chain_Control *header,
Watchdog_Adjust_directions direction,
Watchdog_Interval units
)
{
a858: e92d41f0 push {r4, r5, r6, r7, r8, lr}
a85c: e1a04000 mov r4, r0
a860: e1a05002 mov r5, r2
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a864: e10f3000 mrs r3, CPSR
a868: e3832080 orr r2, r3, #128 ; 0x80
a86c: e129f002 msr CPSR_fc, r2
*/
RTEMS_INLINE_ROUTINE bool _Chain_Is_empty(
Chain_Control *the_chain
)
{
return (the_chain->first == _Chain_Tail(the_chain));
a870: e1a07000 mov r7, r0
a874: e4972004 ldr r2, [r7], #4
* hence the compiler must not assume *header to remain
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
a878: e1520007 cmp r2, r7
a87c: 0a000018 beq a8e4 <_Watchdog_Adjust+0x8c>
switch ( direction ) {
a880: e3510000 cmp r1, #0
a884: 1a000018 bne a8ec <_Watchdog_Adjust+0x94>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
a888: e3550000 cmp r5, #0
a88c: 0a000014 beq a8e4 <_Watchdog_Adjust+0x8c>
if ( units < _Watchdog_First( header )->delta_interval ) {
a890: e5926010 ldr r6, [r2, #16]
a894: e1550006 cmp r5, r6
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
a898: 23a08001 movcs r8, #1
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
a89c: 2a000005 bcs a8b8 <_Watchdog_Adjust+0x60>
a8a0: ea000018 b a908 <_Watchdog_Adjust+0xb0> <== NOT EXECUTED
switch ( direction ) {
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
a8a4: e0555006 subs r5, r5, r6
a8a8: 0a00000d beq a8e4 <_Watchdog_Adjust+0x8c>
if ( units < _Watchdog_First( header )->delta_interval ) {
a8ac: e5926010 ldr r6, [r2, #16]
a8b0: e1560005 cmp r6, r5
a8b4: 8a000013 bhi a908 <_Watchdog_Adjust+0xb0>
_Watchdog_First( header )->delta_interval -= units;
break;
} else {
units -= _Watchdog_First( header )->delta_interval;
_Watchdog_First( header )->delta_interval = 1;
a8b8: e5828010 str r8, [r2, #16]
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a8bc: e129f003 msr CPSR_fc, r3
_ISR_Enable( level );
_Watchdog_Tickle( header );
a8c0: e1a00004 mov r0, r4
a8c4: eb00009e bl ab44 <_Watchdog_Tickle>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
a8c8: e10f3000 mrs r3, CPSR
a8cc: e3832080 orr r2, r3, #128 ; 0x80
a8d0: e129f002 msr CPSR_fc, r2
a8d4: e5941000 ldr r1, [r4]
_ISR_Disable( level );
if ( _Chain_Is_empty( header ) )
a8d8: e1570001 cmp r7, r1
RTEMS_INLINE_ROUTINE Watchdog_Control *_Watchdog_First(
Chain_Control *header
)
{
return ( (Watchdog_Control *) header->first );
a8dc: e1a02001 mov r2, r1
a8e0: 1affffef bne a8a4 <_Watchdog_Adjust+0x4c>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
a8e4: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
a8e8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* unmodified across that call.
*
* Till Straumann, 7/2003
*/
if ( !_Chain_Is_empty( header ) ) {
switch ( direction ) {
a8ec: e3510001 cmp r1, #1
a8f0: 1afffffb bne a8e4 <_Watchdog_Adjust+0x8c>
case WATCHDOG_BACKWARD:
_Watchdog_First( header )->delta_interval += units;
a8f4: e5921010 ldr r1, [r2, #16]
a8f8: e0815005 add r5, r1, r5
a8fc: e5825010 str r5, [r2, #16]
a900: e129f003 msr CPSR_fc, r3
}
}
_ISR_Enable( level );
}
a904: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
_Watchdog_First( header )->delta_interval += units;
break;
case WATCHDOG_FORWARD:
while ( units ) {
if ( units < _Watchdog_First( header )->delta_interval ) {
_Watchdog_First( header )->delta_interval -= units;
a908: e0655006 rsb r5, r5, r6
a90c: e5825010 str r5, [r2, #16]
break;
a910: eafffff3 b a8e4 <_Watchdog_Adjust+0x8c>
0002207c <__kill>:
#endif
int __kill( pid_t pid, int sig )
{
return 0;
}
2207c: e3a00000 mov r0, #0 <== NOT EXECUTED 22080: e12fff1e bx lr <== NOT EXECUTED
00019d78 <_exit>:
/*
* If the toolset uses init/fini sections, then we need to
* run the global destructors now.
*/
#if defined(__USE_INIT_FINI__)
FINI_SYMBOL();
19d78: e24dd004 sub sp, sp, #4 19d7c: e58d0000 str r0, [sp] 19d80: eb0001f2 bl 1a550 <___DTOR_END__>
* We need to do the exit processing on the global reentrancy structure.
* This has already been done on the per task reentrancy structure
* associated with this task.
*/
libc_wrapup();
19d84: ebffffe1 bl 19d10 <libc_wrapup>
rtems_shutdown_executive(status);
19d88: e59d0000 ldr r0, [sp] 19d8c: eb00003e bl 19e8c <rtems_shutdown_executive>
19d90: eafffffe b 19d90 <_exit+0x18> <== NOT EXECUTED
00026648 <_fat_block_read>:
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
26648: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
2664c: e2534000 subs r4, r3, #0 <== NOT EXECUTED
uint32_t start,
uint32_t offset,
uint32_t count,
void *buff
)
{
26650: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
26654: e5909034 ldr r9, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
26658: 01a05004 moveq r5, r4 <== NOT EXECUTED 2665c: 0a00001d beq 266d8 <_fat_block_read+0x90> <== NOT EXECUTED
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
26660: e3a05000 mov r5, #0 <== NOT EXECUTED 26664: e28db004 add fp, sp, #4 <== NOT EXECUTED 26668: e52b5004 str r5, [fp, #-4]! <== NOT EXECUTED 2666c: e1a07002 mov r7, r2 <== NOT EXECUTED 26670: e1a06001 mov r6, r1 <== NOT EXECUTED 26674: ea00000d b 266b0 <_fat_block_read+0x68> <== NOT EXECUTED
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
26678: e1d980b0 ldrh r8, [r9] <== NOT EXECUTED
memcpy((buff + cmpltd), (block->buffer + ofs), c);
2667c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
26680: e0678008 rsb r8, r7, r8 <== NOT EXECUTED
memcpy((buff + cmpltd), (block->buffer + ofs), c);
26684: e5931020 ldr r1, [r3, #32] <== NOT EXECUTED
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
26688: e1580004 cmp r8, r4 <== NOT EXECUTED 2668c: 21a08004 movcs r8, r4 <== NOT EXECUTED
memcpy((buff + cmpltd), (block->buffer + ofs), c);
26690: e0811007 add r1, r1, r7 <== NOT EXECUTED 26694: e1a02008 mov r2, r8 <== NOT EXECUTED 26698: eb007f04 bl 462b0 <memcpy> <== NOT EXECUTED
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
2669c: e0544008 subs r4, r4, r8 <== NOT EXECUTED
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
count -= c;
cmpltd += c;
266a0: e0885005 add r5, r8, r5 <== NOT EXECUTED
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
266a4: 0a00000b beq 266d8 <_fat_block_read+0x90> <== NOT EXECUTED
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
count -= c;
cmpltd += c;
blk++;
266a8: e2866001 add r6, r6, #1 <== NOT EXECUTED 266ac: e1a0700a mov r7, sl <== NOT EXECUTED
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while (count > 0)
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
266b0: e1a0300d mov r3, sp <== NOT EXECUTED 266b4: e1a01006 mov r1, r6 <== NOT EXECUTED 266b8: e1a00009 mov r0, r9 <== NOT EXECUTED 266bc: e3a02001 mov r2, #1 <== NOT EXECUTED 266c0: ebfffe8d bl 260fc <fat_buf_access> <== NOT EXECUTED
if (rc != RC_OK)
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
266c4: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
uint32_t c = 0;
while (count > 0)
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
266c8: e250a000 subs sl, r0, #0 <== NOT EXECUTED
return -1;
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
266cc: e0830005 add r0, r3, r5 <== NOT EXECUTED
uint32_t c = 0;
while (count > 0)
{
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
266d0: 0affffe8 beq 26678 <_fat_block_read+0x30> <== NOT EXECUTED
c = MIN(count, (fs_info->vol.bps - ofs));
memcpy((buff + cmpltd), (block->buffer + ofs), c);
count -= c;
cmpltd += c;
blk++;
266d4: e3e05000 mvn r5, #0 <== NOT EXECUTED
ofs = 0;
}
return cmpltd;
}
266d8: e1a00005 mov r0, r5 <== NOT EXECUTED
266dc: e28dd004 add sp, sp, #4 <== NOT EXECUTED
266e0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
000260f4 <_fat_block_release>:
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
260f4: e5900034 ldr r0, [r0, #52] ; 0x34 <== NOT EXECUTED 260f8: eaffffa4 b 25f90 <fat_buf_release> <== NOT EXECUTED
00026314 <_fat_block_write>:
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
26314: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
26318: e2535000 subs r5, r3, #0 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start,
uint32_t offset,
uint32_t count,
const void *buff)
{
2631c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
26320: e5907034 ldr r7, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
26324: 01a06005 moveq r6, r5 <== NOT EXECUTED 26328: 0a00002d beq 263e4 <_fat_block_write+0xd0> <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
ssize_t cmpltd = 0;
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
2632c: e3a06000 mov r6, #0 <== NOT EXECUTED 26330: e28db004 add fp, sp, #4 <== NOT EXECUTED 26334: e52b6004 str r6, [fp, #-4]! <== NOT EXECUTED 26338: e1a08002 mov r8, r2 <== NOT EXECUTED 2633c: e1a09001 mov r9, r1 <== NOT EXECUTED 26340: ea000015 b 2639c <_fat_block_write+0x88> <== NOT EXECUTED
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
26344: e1a01009 mov r1, r9 <== NOT EXECUTED 26348: e1a0300d mov r3, sp <== NOT EXECUTED 2634c: e3a02001 mov r2, #1 <== NOT EXECUTED 26350: e1a00007 mov r0, r7 <== NOT EXECUTED 26354: ebffff68 bl 260fc <fat_buf_access> <== NOT EXECUTED
if (rc != RC_OK)
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
26358: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
2635c: e1a0a000 mov sl, r0 <== NOT EXECUTED
if (rc != RC_OK)
26360: e35a0000 cmp sl, #0 <== NOT EXECUTED
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
26364: e0831006 add r1, r3, r6 <== NOT EXECUTED 26368: e1a02004 mov r2, r4 <== NOT EXECUTED
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
2636c: 1a00001b bne 263e0 <_fat_block_write+0xcc> <== NOT EXECUTED
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
26370: e59d3000 ldr r3, [sp] <== NOT EXECUTED 26374: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 26378: e0800008 add r0, r0, r8 <== NOT EXECUTED 2637c: eb007fcb bl 462b0 <memcpy> <== NOT EXECUTED
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
26380: e3a03001 mov r3, #1 <== NOT EXECUTED
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
26384: e0555004 subs r5, r5, r4 <== NOT EXECUTED 26388: e5c73080 strb r3, [r7, #128] ; 0x80 <== NOT EXECUTED
memcpy((block->buffer + ofs), (buff + cmpltd), c);
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
2638c: e0846006 add r6, r4, r6 <== NOT EXECUTED
uint32_t blk = start;
uint32_t ofs = offset;
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
26390: 0a000013 beq 263e4 <_fat_block_write+0xd0> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
blk++;
26394: e2899001 add r9, r9, #1 <== NOT EXECUTED 26398: e1a0800a mov r8, sl <== NOT EXECUTED
rtems_bdbuf_buffer *block = NULL;
uint32_t c = 0;
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
2639c: e1d730b0 ldrh r3, [r7] <== NOT EXECUTED 263a0: e0684003 rsb r4, r8, r3 <== NOT EXECUTED 263a4: e1540005 cmp r4, r5 <== NOT EXECUTED 263a8: 21a04005 movcs r4, r5 <== NOT EXECUTED
if (c == fs_info->vol.bps)
263ac: e1530004 cmp r3, r4 <== NOT EXECUTED 263b0: 1affffe3 bne 26344 <_fat_block_write+0x30> <== NOT EXECUTED
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
263b4: e1a01009 mov r1, r9 <== NOT EXECUTED 263b8: e3a02002 mov r2, #2 <== NOT EXECUTED 263bc: e1a0300d mov r3, sp <== NOT EXECUTED 263c0: e1a00007 mov r0, r7 <== NOT EXECUTED 263c4: ebffff4c bl 260fc <fat_buf_access> <== NOT EXECUTED
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
263c8: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
while(count > 0)
{
c = MIN(count, (fs_info->vol.bps - ofs));
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
263cc: e1a0a000 mov sl, r0 <== NOT EXECUTED
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
263d0: e35a0000 cmp sl, #0 <== NOT EXECUTED
return -1;
memcpy((block->buffer + ofs), (buff + cmpltd), c);
263d4: e0831006 add r1, r3, r6 <== NOT EXECUTED 263d8: e1a02004 mov r2, r4 <== NOT EXECUTED
if (c == fs_info->vol.bps)
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_GET, &block);
else
rc = fat_buf_access(fs_info, blk, FAT_OP_TYPE_READ, &block);
if (rc != RC_OK)
263dc: 0affffe3 beq 26370 <_fat_block_write+0x5c> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
count -= c;
cmpltd +=c;
blk++;
263e0: e3e06000 mvn r6, #0 <== NOT EXECUTED
ofs = 0;
}
return cmpltd;
}
263e4: e1a00006 mov r0, r6 <== NOT EXECUTED
263e8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
263ec: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0003f9d4 <_fcntl_r>:
int fd,
int cmd,
int arg
)
{
return fcntl( fd, cmd, arg );
3f9d4: e1a00001 mov r0, r1 <== NOT EXECUTED 3f9d8: e1a01002 mov r1, r2 <== NOT EXECUTED 3f9dc: e1a02003 mov r2, r3 <== NOT EXECUTED 3f9e0: eaffff81 b 3f7ec <fcntl> <== NOT EXECUTED
0002205c <_getpid_r>:
pid_t _getpid_r(
struct _reent *ptr __attribute__((unused))
)
{
return getpid();
}
2205c: e3a00001 mov r0, #1 <== NOT EXECUTED 22060: e12fff1e bx lr <== NOT EXECUTED
000021b4 <_gettimeofday>:
int _gettimeofday(
struct timeval *tp,
struct timezone *tzp
)
{
return gettimeofday( tp, tzp );
21b4: eaffffe4 b 214c <gettimeofday> <== NOT EXECUTED
00022074 <_kill_r>:
#include <reent.h>
int _kill_r( struct _reent *ptr, pid_t pid, int sig )
{
return 0;
}
22074: e3a00000 mov r0, #0 <== NOT EXECUTED 22078: e12fff1e bx lr <== NOT EXECUTED
00029db8 <_link_r>:
struct _reent *ptr __attribute__((unused)),
const char *existing,
const char *new
)
{
return link( existing, new );
29db8: e1a00001 mov r0, r1 <== NOT EXECUTED 29dbc: e1a01002 mov r1, r2 <== NOT EXECUTED 29dc0: eaffff75 b 29b9c <link> <== NOT EXECUTED
0002a004 <_lstat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
2a004: e1a00001 mov r0, r1 <== NOT EXECUTED 2a008: e1a01002 mov r1, r2 <== NOT EXECUTED 2a00c: eaffffc2 b 29f1c <lstat> <== NOT EXECUTED
00019e70 <_realloc_r>:
struct _reent *ignored __attribute__((unused)),
void *ptr,
size_t size
)
{
return realloc( ptr, size );
19e70: e1a00001 mov r0, r1 <== NOT EXECUTED 19e74: e1a01002 mov r1, r2 <== NOT EXECUTED 19e78: ea00000e b 19eb8 <realloc> <== NOT EXECUTED
0005ccac <_rename_r>:
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
5ccac: e92d41f0 push {r4, r5, r6, r7, r8, lr}
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
5ccb0: e1a00001 mov r0, r1
int _rename_r(
struct _reent *ptr __attribute__((unused)),
const char *old,
const char *new
)
{
5ccb4: e24dd048 sub sp, sp, #72 ; 0x48 5ccb8: e1a05001 mov r5, r1 5ccbc: e1a06002 mov r6, r2
/*
* Get the parent node of the old path to be renamed. Find the parent path.
*/
old_parent_pathlen = rtems_filesystem_dirname ( old );
5ccc0: ebfeabbb bl 7bb4 <rtems_filesystem_dirname>
if ( old_parent_pathlen == 0 )
5ccc4: e2507000 subs r7, r0, #0
5ccc8: 1a00008b bne 5cefc <_rename_r+0x250>
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
5cccc: e28d4018 add r4, sp, #24 5ccd0: e1a00005 mov r0, r5 5ccd4: e28d1044 add r1, sp, #68 ; 0x44 5ccd8: e1a02004 mov r2, r4 5ccdc: ebfeb292 bl 972c <rtems_filesystem_get_start_loc> 5cce0: e1a08007 mov r8, r7
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
5cce4: e1a0e004 mov lr, r4
5cce8: e8be000f ldm lr!, {r0, r1, r2, r3}
5ccec: e28dc02c add ip, sp, #44 ; 0x2c
5ccf0: e8ac000f stmia ip!, {r0, r1, r2, r3}
5ccf4: e59e3000 ldr r3, [lr]
name = old + old_parent_pathlen;
5ccf8: e0855007 add r5, r5, r7
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
5ccfc: e58c3000 str r3, [ip]
name = old + old_parent_pathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
5cd00: e1a00005 mov r0, r5
/*
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
name = old + old_parent_pathlen;
5cd04: e58d5040 str r5, [sp, #64] ; 0x40
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
5cd08: ebffb3b5 bl 49be4 <strlen> 5cd0c: e1a01000 mov r1, r0 5cd10: e1a00005 mov r0, r5 5cd14: ebfeab91 bl 7b60 <rtems_filesystem_prefix_separators> 5cd18: e0855000 add r5, r5, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
5cd1c: e1a00005 mov r0, r5
* Start from the parent to find the node that should be under it.
*/
old_loc = old_parent_loc;
name = old + old_parent_pathlen;
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
5cd20: e58d5040 str r5, [sp, #64] ; 0x40
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
5cd24: ebffb3ae bl 49be4 <strlen> 5cd28: e28d702c add r7, sp, #44 ; 0x2c 5cd2c: e3a0c000 mov ip, #0 5cd30: e1a01000 mov r1, r0 5cd34: e1a0200c mov r2, ip 5cd38: e1a00005 mov r0, r5 5cd3c: e1a03007 mov r3, r7 5cd40: e58dc000 str ip, [sp] 5cd44: ebfeabab bl 7bf8 <rtems_filesystem_evaluate_relative_path>
0, &old_loc, false );
if ( result != 0 ) {
5cd48: e3500000 cmp r0, #0
5cd4c: 1a00005b bne 5cec0 <_rename_r+0x214>
/*
* Get the parent of the new node we are renaming to.
*/
rtems_filesystem_get_start_loc( new, &i, &new_parent_loc );
5cd50: e28d5004 add r5, sp, #4 5cd54: e1a00006 mov r0, r6 5cd58: e28d1044 add r1, sp, #68 ; 0x44 5cd5c: e1a02005 mov r2, r5 5cd60: ebfeb271 bl 972c <rtems_filesystem_get_start_loc>
if ( !new_parent_loc.ops->evalformake_h ) {
5cd64: e59d3010 ldr r3, [sp, #16] 5cd68: e5933004 ldr r3, [r3, #4] 5cd6c: e3530000 cmp r3, #0
5cd70: 0a00008f beq 5cfb4 <_rename_r+0x308>
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
5cd74: e59d0044 ldr r0, [sp, #68] ; 0x44 5cd78: e1a01005 mov r1, r5 5cd7c: e0860000 add r0, r6, r0 5cd80: e28d2040 add r2, sp, #64 ; 0x40 5cd84: e1a0e00f mov lr, pc 5cd88: e12fff13 bx r3
if ( result != 0 ) {
5cd8c: e3500000 cmp r0, #0
5cd90: 1a000065 bne 5cf2c <_rename_r+0x280>
/*
* Check to see if the caller is trying to rename across file system
* boundaries.
*/
if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) {
5cd94: e59d3014 ldr r3, [sp, #20] 5cd98: e59d2028 ldr r2, [sp, #40] ; 0x28 5cd9c: e1520003 cmp r2, r3
5cda0: 1a000027 bne 5ce44 <_rename_r+0x198>
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
rtems_set_errno_and_return_minus_one( EXDEV );
}
if ( !new_parent_loc.ops->rename_h ) {
5cda4: e59d3010 ldr r3, [sp, #16] 5cda8: e593c040 ldr ip, [r3, #64] ; 0x40 5cdac: e35c0000 cmp ip, #0
5cdb0: 0a00007a beq 5cfa0 <_rename_r+0x2f4>
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
5cdb4: e59d3040 ldr r3, [sp, #64] ; 0x40 5cdb8: e1a00004 mov r0, r4 5cdbc: e1a01007 mov r1, r7 5cdc0: e1a02005 mov r2, r5 5cdc4: e1a0e00f mov lr, pc 5cdc8: e12fff1c bx ip
rtems_filesystem_freenode( &new_parent_loc );
5cdcc: e59d3010 ldr r3, [sp, #16] 5cdd0: e3530000 cmp r3, #0
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
5cdd4: e1a06000 mov r6, r0
rtems_filesystem_freenode( &new_parent_loc );
5cdd8: 0a000004 beq 5cdf0 <_rename_r+0x144>
5cddc: e593301c ldr r3, [r3, #28] 5cde0: e3530000 cmp r3, #0 5cde4: 11a00005 movne r0, r5 5cde8: 11a0e00f movne lr, pc 5cdec: 112fff13 bxne r3
if ( free_old_parentloc )
5cdf0: e3580000 cmp r8, #0
5cdf4: 0a000007 beq 5ce18 <_rename_r+0x16c>
rtems_filesystem_freenode( &old_parent_loc );
5cdf8: e59d3024 ldr r3, [sp, #36] ; 0x24 5cdfc: e3530000 cmp r3, #0
5ce00: 0a000004 beq 5ce18 <_rename_r+0x16c>
5ce04: e593301c ldr r3, [r3, #28] 5ce08: e3530000 cmp r3, #0 5ce0c: 11a00004 movne r0, r4 5ce10: 11a0e00f movne lr, pc 5ce14: 112fff13 bxne r3
rtems_filesystem_freenode( &old_loc );
5ce18: e59d3038 ldr r3, [sp, #56] ; 0x38 5ce1c: e3530000 cmp r3, #0
5ce20: 0a000004 beq 5ce38 <_rename_r+0x18c>
5ce24: e593301c ldr r3, [r3, #28] 5ce28: e3530000 cmp r3, #0 5ce2c: 11a00007 movne r0, r7 5ce30: 11a0e00f movne lr, pc 5ce34: 112fff13 bxne r3
return result;
}
5ce38: e1a00006 mov r0, r6
5ce3c: e28dd048 add sp, sp, #72 ; 0x48
5ce40: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
* Check to see if the caller is trying to rename across file system
* boundaries.
*/
if ( old_parent_loc.mt_entry != new_parent_loc.mt_entry ) {
rtems_filesystem_freenode( &new_parent_loc );
5ce44: e59d3010 ldr r3, [sp, #16] 5ce48: e3530000 cmp r3, #0
5ce4c: 0a000004 beq 5ce64 <_rename_r+0x1b8>
5ce50: e593301c ldr r3, [r3, #28] 5ce54: e3530000 cmp r3, #0 5ce58: 11a00005 movne r0, r5 5ce5c: 11a0e00f movne lr, pc 5ce60: 112fff13 bxne r3
if ( free_old_parentloc )
5ce64: e3580000 cmp r8, #0
5ce68: 0a000007 beq 5ce8c <_rename_r+0x1e0>
rtems_filesystem_freenode( &old_parent_loc );
5ce6c: e59d3024 ldr r3, [sp, #36] ; 0x24 5ce70: e3530000 cmp r3, #0
5ce74: 0a000004 beq 5ce8c <_rename_r+0x1e0>
5ce78: e593301c ldr r3, [r3, #28] 5ce7c: e3530000 cmp r3, #0 5ce80: 11a00004 movne r0, r4 5ce84: 11a0e00f movne lr, pc 5ce88: 112fff13 bxne r3
rtems_filesystem_freenode( &old_loc );
5ce8c: e59d3038 ldr r3, [sp, #56] ; 0x38 5ce90: e3530000 cmp r3, #0
5ce94: 0a000004 beq 5ceac <_rename_r+0x200>
5ce98: e593301c ldr r3, [r3, #28] 5ce9c: e3530000 cmp r3, #0 5cea0: 11a00007 movne r0, r7 5cea4: 11a0e00f movne lr, pc 5cea8: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( EXDEV );
5ceac: ebff984f bl 42ff0 <__errno> 5ceb0: e3a03012 mov r3, #18 5ceb4: e5803000 str r3, [r0] 5ceb8: e3e06000 mvn r6, #0 5cebc: eaffffdd b 5ce38 <_rename_r+0x18c>
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &old_loc, false );
if ( result != 0 ) {
if ( free_old_parentloc )
5cec0: e3580000 cmp r8, #0
5cec4: 1a000001 bne 5ced0 <_rename_r+0x224>
result = (*new_parent_loc.ops->rename_h)( &old_parent_loc, &old_loc, &new_parent_loc, name );
rtems_filesystem_freenode( &new_parent_loc );
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
rtems_filesystem_freenode( &old_loc );
5cec8: e3e06000 mvn r6, #0 <== NOT EXECUTED 5cecc: eaffffd9 b 5ce38 <_rename_r+0x18c> <== NOT EXECUTED
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &old_loc, false );
if ( result != 0 ) {
if ( free_old_parentloc )
rtems_filesystem_freenode( &old_parent_loc );
5ced0: e59d3024 ldr r3, [sp, #36] ; 0x24 5ced4: e3530000 cmp r3, #0
5ced8: 0afffffa beq 5cec8 <_rename_r+0x21c>
5cedc: e593301c ldr r3, [r3, #28] 5cee0: e3530000 cmp r3, #0
5cee4: 0afffff7 beq 5cec8 <_rename_r+0x21c>
5cee8: e1a00004 mov r0, r4 5ceec: e1a0e00f mov lr, pc 5cef0: e12fff13 bx r3 5cef4: e3e06000 mvn r6, #0 5cef8: eaffffce b 5ce38 <_rename_r+0x18c>
old_parent_pathlen = rtems_filesystem_dirname ( old );
if ( old_parent_pathlen == 0 )
rtems_filesystem_get_start_loc( old, &i, &old_parent_loc );
else {
result = rtems_filesystem_evaluate_path( old, old_parent_pathlen,
5cefc: e28d4018 add r4, sp, #24 5cf00: e3a0c000 mov ip, #0 5cf04: e1a00005 mov r0, r5 5cf08: e1a01007 mov r1, r7 5cf0c: e3a02002 mov r2, #2 5cf10: e1a03004 mov r3, r4 5cf14: e58dc000 str ip, [sp] 5cf18: ebfeab72 bl 7ce8 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&old_parent_loc,
false );
if ( result != 0 )
5cf1c: e3500000 cmp r0, #0
5cf20: 1affffe8 bne 5cec8 <_rename_r+0x21c>
5cf24: e3a08001 mov r8, #1 5cf28: eaffff6d b 5cce4 <_rename_r+0x38>
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*new_parent_loc.ops->evalformake_h)( &new[i], &new_parent_loc, &name );
if ( result != 0 ) {
rtems_filesystem_freenode( &new_parent_loc );
5cf2c: e59d3010 ldr r3, [sp, #16] 5cf30: e3530000 cmp r3, #0
5cf34: 0a000004 beq 5cf4c <_rename_r+0x2a0>
5cf38: e593301c ldr r3, [r3, #28] 5cf3c: e3530000 cmp r3, #0 5cf40: 11a00005 movne r0, r5 5cf44: 11a0e00f movne lr, pc 5cf48: 112fff13 bxne r3
if ( free_old_parentloc )
5cf4c: e3580000 cmp r8, #0
5cf50: 0a000007 beq 5cf74 <_rename_r+0x2c8>
rtems_filesystem_freenode( &old_parent_loc );
5cf54: e59d3024 ldr r3, [sp, #36] ; 0x24 5cf58: e3530000 cmp r3, #0
5cf5c: 0a000004 beq 5cf74 <_rename_r+0x2c8>
5cf60: e593301c ldr r3, [r3, #28] 5cf64: e3530000 cmp r3, #0 5cf68: 11a00004 movne r0, r4 5cf6c: 11a0e00f movne lr, pc 5cf70: 112fff13 bxne r3
rtems_filesystem_freenode( &old_loc );
5cf74: e59d3038 ldr r3, [sp, #56] ; 0x38 5cf78: e3530000 cmp r3, #0
5cf7c: 0affffd1 beq 5cec8 <_rename_r+0x21c>
5cf80: e593301c ldr r3, [r3, #28] 5cf84: e3530000 cmp r3, #0
5cf88: 0affffce beq 5cec8 <_rename_r+0x21c>
5cf8c: e1a00007 mov r0, r7 5cf90: e1a0e00f mov lr, pc 5cf94: e12fff13 bx r3 5cf98: e3e06000 mvn r6, #0 5cf9c: eaffffa5 b 5ce38 <_rename_r+0x18c>
rtems_filesystem_freenode( &old_loc );
rtems_set_errno_and_return_minus_one( EXDEV );
}
if ( !new_parent_loc.ops->rename_h ) {
rtems_filesystem_freenode( &new_parent_loc );
5cfa0: e593301c ldr r3, [r3, #28] 5cfa4: e3530000 cmp r3, #0 5cfa8: 11a00005 movne r0, r5 5cfac: 11a0e00f movne lr, pc 5cfb0: 112fff13 bxne r3
if ( free_old_parentloc )
5cfb4: e3580000 cmp r8, #0
5cfb8: 0a000007 beq 5cfdc <_rename_r+0x330>
rtems_filesystem_freenode( &old_parent_loc );
5cfbc: e59d3024 ldr r3, [sp, #36] ; 0x24 5cfc0: e3530000 cmp r3, #0
5cfc4: 0a000004 beq 5cfdc <_rename_r+0x330>
5cfc8: e593301c ldr r3, [r3, #28] 5cfcc: e3530000 cmp r3, #0 5cfd0: 11a00004 movne r0, r4 5cfd4: 11a0e00f movne lr, pc 5cfd8: 112fff13 bxne r3
rtems_filesystem_freenode( &old_loc );
5cfdc: e59d3038 ldr r3, [sp, #56] ; 0x38 5cfe0: e3530000 cmp r3, #0
5cfe4: 0a000004 beq 5cffc <_rename_r+0x350>
5cfe8: e593301c ldr r3, [r3, #28] 5cfec: e3530000 cmp r3, #0 5cff0: 11a00007 movne r0, r7 5cff4: 11a0e00f movne lr, pc 5cff8: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( ENOTSUP );
5cffc: ebff97fb bl 42ff0 <__errno> 5d000: e3a03086 mov r3, #134 ; 0x86 5d004: e5803000 str r3, [r0] 5d008: e3e06000 mvn r6, #0 5d00c: eaffff89 b 5ce38 <_rename_r+0x18c>
00009720 <_stat_r>:
struct _reent *ptr __attribute__((unused)),
const char *path,
struct stat *buf
)
{
return _STAT_NAME( path, buf );
9720: e1a00001 mov r0, r1 <== NOT EXECUTED
9724: e1a01002 mov r1, r2 <== NOT EXECUTED
9728: eaffffc2 b 9638 <stat> <== NOT EXECUTED
0000dd70 <_unlink_r>:
int _unlink_r(
struct _reent *ptr __attribute__((unused)),
const char *path
)
{
return unlink( path );
dd70: e1a00001 mov r0, r1 <== NOT EXECUTED
dd74: eaffff6c b db2c <unlink> <== NOT EXECUTED
00028b0c <chdir>:
#include <rtems/seterr.h>
int chdir(
const char *pathname
)
{
28b0c: e92d4030 push {r4, r5, lr}
rtems_filesystem_location_info_t loc;
int result;
if ( !pathname )
28b10: e2505000 subs r5, r0, #0
#include <rtems/seterr.h>
int chdir(
const char *pathname
)
{
28b14: e24dd018 sub sp, sp, #24
rtems_filesystem_location_info_t loc;
int result;
if ( !pathname )
28b18: 0a000031 beq 28be4 <chdir+0xd8>
rtems_set_errno_and_return_minus_one( EFAULT );
/*
* Get the node where we wish to go.
*/
result = rtems_filesystem_evaluate_path(
28b1c: eb008430 bl 49be4 <strlen> 28b20: e28d4004 add r4, sp, #4 28b24: e3a0c001 mov ip, #1 28b28: e1a01000 mov r1, r0 28b2c: e1a0200c mov r2, ip 28b30: e1a00005 mov r0, r5 28b34: e1a03004 mov r3, r4 28b38: e58dc000 str ip, [sp] 28b3c: ebff7c69 bl 7ce8 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), RTEMS_LIBIO_PERMS_SEARCH, &loc, true );
if ( result != 0 )
28b40: e3500000 cmp r0, #0
28b44: 1a000024 bne 28bdc <chdir+0xd0>
return -1;
/*
* Verify you can change directory into this node.
*/
if ( !loc.ops->node_type_h ) {
28b48: e59d2010 ldr r2, [sp, #16] 28b4c: e5923010 ldr r3, [r2, #16] 28b50: e3530000 cmp r3, #0
28b54: 0a000018 beq 28bbc <chdir+0xb0>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
28b58: e1a00004 mov r0, r4 28b5c: e1a0e00f mov lr, pc 28b60: e12fff13 bx r3 28b64: e3500001 cmp r0, #1
28b68: 1a000022 bne 28bf8 <chdir+0xec>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTDIR );
}
rtems_filesystem_freenode( &rtems_filesystem_current );
28b6c: e59f50b8 ldr r5, [pc, #184] ; 28c2c <chdir+0x120> 28b70: e595c000 ldr ip, [r5] 28b74: e59c3010 ldr r3, [ip, #16] 28b78: e3530000 cmp r3, #0
28b7c: 0a000006 beq 28b9c <chdir+0x90>
28b80: e593301c ldr r3, [r3, #28] 28b84: e3530000 cmp r3, #0
28b88: 0a000003 beq 28b9c <chdir+0x90>
28b8c: e28c0004 add r0, ip, #4 28b90: e1a0e00f mov lr, pc 28b94: e12fff13 bx r3 28b98: e595c000 ldr ip, [r5]
rtems_filesystem_current = loc;
28b9c: e8b4000f ldm r4!, {r0, r1, r2, r3}
28ba0: e28cc004 add ip, ip, #4
28ba4: e8ac000f stmia ip!, {r0, r1, r2, r3}
28ba8: e5943000 ldr r3, [r4]
28bac: e58c3000 str r3, [ip]
28bb0: e3a00000 mov r0, #0
return 0;
}
28bb4: e28dd018 add sp, sp, #24
28bb8: e8bd8030 pop {r4, r5, pc}
/*
* Verify you can change directory into this node.
*/
if ( !loc.ops->node_type_h ) {
rtems_filesystem_freenode( &loc );
28bbc: e592301c ldr r3, [r2, #28] <== NOT EXECUTED 28bc0: e3530000 cmp r3, #0 <== NOT EXECUTED 28bc4: 11a00004 movne r0, r4 <== NOT EXECUTED 28bc8: 11a0e00f movne lr, pc <== NOT EXECUTED 28bcc: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
28bd0: eb006906 bl 42ff0 <__errno> <== NOT EXECUTED 28bd4: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 28bd8: e5803000 str r3, [r0] <== NOT EXECUTED
28bdc: e3e00000 mvn r0, #0 28be0: eafffff3 b 28bb4 <chdir+0xa8>
{
rtems_filesystem_location_info_t loc;
int result;
if ( !pathname )
rtems_set_errno_and_return_minus_one( EFAULT );
28be4: eb006901 bl 42ff0 <__errno> 28be8: e3a0300e mov r3, #14 28bec: e5803000 str r3, [r0] 28bf0: e3e00000 mvn r0, #0 28bf4: eaffffee b 28bb4 <chdir+0xa8>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
28bf8: e59d3010 ldr r3, [sp, #16] 28bfc: e3530000 cmp r3, #0
28c00: 0a000004 beq 28c18 <chdir+0x10c>
28c04: e593301c ldr r3, [r3, #28] 28c08: e3530000 cmp r3, #0 28c0c: 11a00004 movne r0, r4 28c10: 11a0e00f movne lr, pc 28c14: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( ENOTDIR );
28c18: eb0068f4 bl 42ff0 <__errno> 28c1c: e3a03014 mov r3, #20 28c20: e5803000 str r3, [r0] 28c24: e3e00000 mvn r0, #0 28c28: eaffffe1 b 28bb4 <chdir+0xa8>
000077a8 <chmod>:
int chmod(
const char *path,
mode_t mode
)
{
77a8: e92d4070 push {r4, r5, r6, lr}
77ac: e24dd018 sub sp, sp, #24
77b0: e1a05001 mov r5, r1
77b4: e1a06000 mov r6, r0
int status;
rtems_filesystem_location_info_t loc;
int result;
status = rtems_filesystem_evaluate_path( path, strlen( path ), 0, &loc, true );
77b8: eb010909 bl 49be4 <strlen>
77bc: e28d4004 add r4, sp, #4
77c0: e1a01000 mov r1, r0
77c4: e3a0c001 mov ip, #1
77c8: e1a00006 mov r0, r6
77cc: e3a02000 mov r2, #0
77d0: e1a03004 mov r3, r4
77d4: e58dc000 str ip, [sp]
77d8: eb000142 bl 7ce8 <rtems_filesystem_evaluate_path>
if ( status != 0 )
77dc: e3500000 cmp r0, #0
77e0: 1a000020 bne 7868 <chmod+0xc0>
return -1;
if ( !loc.handlers ){
77e4: e59d300c ldr r3, [sp, #12]
77e8: e3530000 cmp r3, #0
77ec: 0a000012 beq 783c <chmod+0x94>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( EBADF );
}
if ( !loc.handlers->fchmod_h ){
77f0: e593301c ldr r3, [r3, #28]
77f4: e3530000 cmp r3, #0
77f8: 0a00001c beq 7870 <chmod+0xc8>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.handlers->fchmod_h)( &loc, mode );
77fc: e1a01005 mov r1, r5
7800: e1a00004 mov r0, r4
7804: e1a0e00f mov lr, pc
7808: e12fff13 bx r3
rtems_filesystem_freenode( &loc );
780c: e59d3010 ldr r3, [sp, #16]
7810: e3530000 cmp r3, #0
if ( !loc.handlers->fchmod_h ){
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.handlers->fchmod_h)( &loc, mode );
7814: e1a05000 mov r5, r0
rtems_filesystem_freenode( &loc );
7818: 0a000004 beq 7830 <chmod+0x88>
781c: e593301c ldr r3, [r3, #28]
7820: e3530000 cmp r3, #0
7824: 11a00004 movne r0, r4
7828: 11a0e00f movne lr, pc
782c: 112fff13 bxne r3
return result;
}
7830: e1a00005 mov r0, r5
7834: e28dd018 add sp, sp, #24
7838: e8bd8070 pop {r4, r5, r6, pc}
status = rtems_filesystem_evaluate_path( path, strlen( path ), 0, &loc, true );
if ( status != 0 )
return -1;
if ( !loc.handlers ){
rtems_filesystem_freenode( &loc );
783c: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
7840: e3530000 cmp r3, #0 <== NOT EXECUTED
7844: 0a000004 beq 785c <chmod+0xb4> <== NOT EXECUTED
7848: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
784c: e3530000 cmp r3, #0 <== NOT EXECUTED
7850: 11a00004 movne r0, r4 <== NOT EXECUTED
7854: 11a0e00f movne lr, pc <== NOT EXECUTED
7858: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EBADF );
785c: eb00ede3 bl 42ff0 <__errno> <== NOT EXECUTED
7860: e3a03009 mov r3, #9 <== NOT EXECUTED
7864: e5803000 str r3, [r0] <== NOT EXECUTED
7868: e3e05000 mvn r5, #0
786c: eaffffef b 7830 <chmod+0x88>
}
if ( !loc.handlers->fchmod_h ){
rtems_filesystem_freenode( &loc );
7870: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
7874: e3530000 cmp r3, #0 <== NOT EXECUTED
7878: 0a000004 beq 7890 <chmod+0xe8> <== NOT EXECUTED
787c: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
7880: e3530000 cmp r3, #0 <== NOT EXECUTED
7884: 11a00004 movne r0, r4 <== NOT EXECUTED
7888: 11a0e00f movne lr, pc <== NOT EXECUTED
788c: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
7890: eb00edd6 bl 42ff0 <__errno> <== NOT EXECUTED
7894: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
7898: e5803000 str r3, [r0] <== NOT EXECUTED
789c: e3e05000 mvn r5, #0 <== NOT EXECUTED
78a0: eaffffe2 b 7830 <chmod+0x88> <== NOT EXECUTED
00028c30 <chown>:
int chown(
const char *path,
uid_t owner,
gid_t group
)
{
28c30: e92d40f0 push {r4, r5, r6, r7, lr}
28c34: e1a01801 lsl r1, r1, #16
28c38: e24dd018 sub sp, sp, #24
28c3c: e1a02802 lsl r2, r2, #16
28c40: e1a06821 lsr r6, r1, #16
28c44: e1a05822 lsr r5, r2, #16
28c48: e1a07000 mov r7, r0
rtems_filesystem_location_info_t loc;
int result;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, true ) )
28c4c: eb0083e4 bl 49be4 <strlen> 28c50: e28d4004 add r4, sp, #4 28c54: e1a01000 mov r1, r0 28c58: e3a0c001 mov ip, #1 28c5c: e1a00007 mov r0, r7 28c60: e3a02000 mov r2, #0 28c64: e1a03004 mov r3, r4 28c68: e58dc000 str ip, [sp] 28c6c: ebff7c1d bl 7ce8 <rtems_filesystem_evaluate_path> 28c70: e3500000 cmp r0, #0
28c74: 1a00001c bne 28cec <chown+0xbc>
return -1;
if ( !loc.ops->chown_h ) {
28c78: e59d2010 ldr r2, [sp, #16] 28c7c: e5923018 ldr r3, [r2, #24] 28c80: e3530000 cmp r3, #0
28c84: 0a000010 beq 28ccc <chown+0x9c>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.ops->chown_h)( &loc, owner, group );
28c88: e1a02005 mov r2, r5 28c8c: e1a01006 mov r1, r6 28c90: e1a00004 mov r0, r4 28c94: e1a0e00f mov lr, pc 28c98: e12fff13 bx r3
rtems_filesystem_freenode( &loc );
28c9c: e59d3010 ldr r3, [sp, #16] 28ca0: e3530000 cmp r3, #0
if ( !loc.ops->chown_h ) {
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.ops->chown_h)( &loc, owner, group );
28ca4: e1a05000 mov r5, r0
rtems_filesystem_freenode( &loc );
28ca8: 0a000004 beq 28cc0 <chown+0x90>
28cac: e593301c ldr r3, [r3, #28] 28cb0: e3530000 cmp r3, #0 28cb4: 11a00004 movne r0, r4 28cb8: 11a0e00f movne lr, pc 28cbc: 112fff13 bxne r3
return result;
}
28cc0: e1a00005 mov r0, r5
28cc4: e28dd018 add sp, sp, #24
28cc8: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &loc, true ) )
return -1;
if ( !loc.ops->chown_h ) {
rtems_filesystem_freenode( &loc );
28ccc: e592301c ldr r3, [r2, #28] <== NOT EXECUTED 28cd0: e3530000 cmp r3, #0 <== NOT EXECUTED 28cd4: 11a00004 movne r0, r4 <== NOT EXECUTED 28cd8: 11a0e00f movne lr, pc <== NOT EXECUTED 28cdc: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
28ce0: eb0068c2 bl 42ff0 <__errno> <== NOT EXECUTED 28ce4: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 28ce8: e5803000 str r3, [r0] <== NOT EXECUTED
28cec: e3e05000 mvn r5, #0 28cf0: eafffff2 b 28cc0 <chown+0x90>
00028cf4 <chroot>:
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
28cf4: e92d4070 push {r4, r5, r6, lr}
int result;
rtems_filesystem_location_info_t loc;
/* an automatic call to new private env the first time */
if (rtems_current_user_env == &rtems_global_user_env) {
28cf8: e59f50d8 ldr r5, [pc, #216] ; 28dd8 <chroot+0xe4> 28cfc: e59f30d8 ldr r3, [pc, #216] ; 28ddc <chroot+0xe8> 28d00: e5954000 ldr r4, [r5] 28d04: e1540003 cmp r4, r3
#include <rtems/seterr.h>
int chroot(
const char *pathname
)
{
28d08: e24dd018 sub sp, sp, #24 28d0c: e1a06000 mov r6, r0
int result;
rtems_filesystem_location_info_t loc;
/* an automatic call to new private env the first time */
if (rtems_current_user_env == &rtems_global_user_env) {
28d10: 0a000020 beq 28d98 <chroot+0xa4>
rtems_libio_set_private_env(); /* try to set a new private env*/
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = chdir(pathname);
28d14: e1a00006 mov r0, r6 28d18: ebffff7b bl 28b0c <chdir>
if (result) {
28d1c: e250c000 subs ip, r0, #0
28d20: 1a000025 bne 28dbc <chroot+0xc8>
rtems_set_errno_and_return_minus_one( errno );
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
28d24: e28d4004 add r4, sp, #4 28d28: e1a0200c mov r2, ip 28d2c: e59f00ac ldr r0, [pc, #172] ; 28de0 <chroot+0xec> 28d30: e3a01001 mov r1, #1 28d34: e1a03004 mov r3, r4 28d38: e58dc000 str ip, [sp] 28d3c: ebff7be9 bl 7ce8 <rtems_filesystem_evaluate_path> 28d40: e3500000 cmp r0, #0
28d44: 1a00001c bne 28dbc <chroot+0xc8>
/* our cwd has changed, though - but there is no easy way of return :-( */
rtems_set_errno_and_return_minus_one( errno );
}
rtems_filesystem_freenode(&rtems_filesystem_root);
28d48: e595c000 ldr ip, [r5] 28d4c: e59c3024 ldr r3, [ip, #36] ; 0x24 28d50: e3530000 cmp r3, #0
28d54: 0a000007 beq 28d78 <chroot+0x84>
28d58: e593301c ldr r3, [r3, #28] 28d5c: e3530000 cmp r3, #0
28d60: 0a000004 beq 28d78 <chroot+0x84>
28d64: e28c0018 add r0, ip, #24 28d68: e1a0e00f mov lr, pc 28d6c: e12fff13 bx r3 28d70: e59f3060 ldr r3, [pc, #96] ; 28dd8 <chroot+0xe4> 28d74: e593c000 ldr ip, [r3]
rtems_filesystem_root = loc;
28d78: e8b4000f ldm r4!, {r0, r1, r2, r3}
28d7c: e28cc018 add ip, ip, #24
28d80: e8ac000f stmia ip!, {r0, r1, r2, r3}
28d84: e5943000 ldr r3, [r4]
28d88: e58c3000 str r3, [ip]
28d8c: e3a00000 mov r0, #0
return 0;
}
28d90: e28dd018 add sp, sp, #24
28d94: e8bd8070 pop {r4, r5, r6, pc}
int result;
rtems_filesystem_location_info_t loc;
/* an automatic call to new private env the first time */
if (rtems_current_user_env == &rtems_global_user_env) {
rtems_libio_set_private_env(); /* try to set a new private env*/
28d98: eb0005cf bl 2a4dc <rtems_libio_set_private_env>
if (rtems_current_user_env == &rtems_global_user_env) /* not ok */
28d9c: e5953000 ldr r3, [r5] 28da0: e1530004 cmp r3, r4
28da4: 1affffda bne 28d14 <chroot+0x20>
rtems_set_errno_and_return_minus_one( ENOTSUP );
28da8: eb006890 bl 42ff0 <__errno> <== NOT EXECUTED 28dac: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 28db0: e5803000 str r3, [r0] <== NOT EXECUTED 28db4: e3e00000 mvn r0, #0 <== NOT EXECUTED 28db8: eafffff4 b 28d90 <chroot+0x9c> <== NOT EXECUTED
}
/* clone the new root location */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
/* our cwd has changed, though - but there is no easy way of return :-( */
rtems_set_errno_and_return_minus_one( errno );
28dbc: eb00688b bl 42ff0 <__errno> <== NOT EXECUTED 28dc0: e1a04000 mov r4, r0 <== NOT EXECUTED 28dc4: eb006889 bl 42ff0 <__errno> <== NOT EXECUTED 28dc8: e5903000 ldr r3, [r0] <== NOT EXECUTED 28dcc: e3e00000 mvn r0, #0 <== NOT EXECUTED 28dd0: e5843000 str r3, [r4] <== NOT EXECUTED 28dd4: eaffffed b 28d90 <chroot+0x9c> <== NOT EXECUTED
00002334 <create_disk>:
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
2334: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
2338: e59f61a0 ldr r6, [pc, #416] ; 24e0 <create_disk+0x1ac>
233c: e5967000 ldr r7, [r6]
2340: e1500007 cmp r0, r7
return disktab [major].minor + minor;
}
static rtems_status_code
create_disk(dev_t dev, const char *name, rtems_disk_device **dd_ptr)
{
2344: e24dd004 sub sp, sp, #4
2348: e1a05000 mov r5, r0
234c: e1a04001 mov r4, r1
2350: e1a09002 mov r9, r2
2354: e1a0b003 mov fp, r3
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
2358: 35968004 ldrcc r8, [r6, #4]
235c: 2a000043 bcs 2470 <create_disk+0x13c>
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab = table;
disktab_size = new_size;
}
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
2360: e7987185 ldr r7, [r8, r5, lsl #3]
2364: e1a0a185 lsl sl, r5, #3
2368: e3570000 cmp r7, #0
236c: e088800a add r8, r8, sl
2370: 05988004 ldreq r8, [r8, #4]
2374: 0a000026 beq 2414 <create_disk+0xe0>
2378: e5988004 ldr r8, [r8, #4]
237c: e1540008 cmp r4, r8
2380: 2a000023 bcs 2414 <create_disk+0xe0>
{
rtems_disk_device **dd_entry = create_disk_table_entry(dev);
rtems_disk_device *dd = NULL;
char *alloc_name = NULL;
if (dd_entry == NULL) {
2384: e0976104 adds r6, r7, r4, lsl #2
2388: 0a000048 beq 24b0 <create_disk+0x17c>
return RTEMS_NO_MEMORY;
}
if (*dd_entry != NULL) {
238c: e7973104 ldr r3, [r7, r4, lsl #2]
2390: e3530000 cmp r3, #0
2394: 13a0000c movne r0, #12
2398: 0a000001 beq 23a4 <create_disk+0x70>
*dd_entry = dd;
*dd_ptr = dd;
return RTEMS_SUCCESSFUL;
}
239c: e28dd004 add sp, sp, #4
23a0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
if (*dd_entry != NULL) {
return RTEMS_RESOURCE_IN_USE;
}
dd = malloc(sizeof(*dd));
23a4: e3a00034 mov r0, #52 ; 0x34
23a8: eb00042d bl 3464 <malloc>
if (dd == NULL) {
23ac: e2507000 subs r7, r0, #0
23b0: 0a00003e beq 24b0 <create_disk+0x17c>
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
23b4: e3590000 cmp r9, #0
23b8: 0a00000c beq 23f0 <create_disk+0xbc>
alloc_name = strdup(name);
23bc: e1a00009 mov r0, r9
23c0: eb00434e bl 13100 <strdup>
if (alloc_name == NULL) {
23c4: e3500000 cmp r0, #0
if (dd == NULL) {
return RTEMS_NO_MEMORY;
}
if (name != NULL) {
alloc_name = strdup(name);
23c8: e1a08000 mov r8, r0
23cc: e1a09000 mov r9, r0
if (alloc_name == NULL) {
23d0: 0a00003e beq 24d0 <create_disk+0x19c>
return RTEMS_NO_MEMORY;
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
23d4: e3a01c61 mov r1, #24832 ; 0x6100
23d8: e28110ff add r1, r1, #255 ; 0xff
23dc: e1a02005 mov r2, r5
23e0: e1a03004 mov r3, r4
23e4: eb000461 bl 3570 <mknod>
23e8: e3500000 cmp r0, #0
23ec: ba000031 blt 24b8 <create_disk+0x184>
}
}
dd->dev = dev;
dd->name = alloc_name;
dd->uses = 0;
23f0: e3a00000 mov r0, #0
dd->deleted = false;
*dd_entry = dd;
23f4: e5867000 str r7, [r6]
free(dd);
return RTEMS_UNSATISFIED;
}
}
dd->dev = dev;
23f8: e5875000 str r5, [r7]
dd->name = alloc_name;
dd->uses = 0;
dd->deleted = false;
*dd_entry = dd;
*dd_ptr = dd;
23fc: e58b7000 str r7, [fp]
free(dd);
return RTEMS_UNSATISFIED;
}
}
dd->dev = dev;
2400: e5874004 str r4, [r7, #4]
dd->name = alloc_name;
2404: e5879010 str r9, [r7, #16]
dd->uses = 0;
2408: e5870014 str r0, [r7, #20]
dd->deleted = false;
240c: e5c70030 strb r0, [r7, #48] ; 0x30
*dd_entry = dd;
*dd_ptr = dd;
return RTEMS_SUCCESSFUL;
2410: eaffffe1 b 239c <create_disk+0x68>
if (disktab [major].minor == NULL || minor >= disktab[major].size) {
rtems_disk_device **table = disktab [major].minor;
rtems_device_minor_number old_size = disktab [major].size;
rtems_device_minor_number new_size = 0;
if (old_size == 0) {
2414: e3580000 cmp r8, #0
2418: 03a03008 moveq r3, #8
new_size = DISKTAB_INITIAL_SIZE;
} else {
new_size = 2 * old_size;
241c: 11a03088 lslne r3, r8, #1
}
if (minor >= new_size) {
2420: e1540003 cmp r4, r3
new_size = minor + 1;
2424: 22843001 addcs r3, r4, #1
}
table = realloc(table, new_size * sizeof(*table));
2428: e1a00007 mov r0, r7
242c: e1a01103 lsl r1, r3, #2
2430: e58d3000 str r3, [sp]
2434: eb0006f3 bl 4008 <realloc>
if (table == NULL) {
2438: e2507000 subs r7, r0, #0
243c: e59d3000 ldr r3, [sp]
2440: 0a00001a beq 24b0 <create_disk+0x17c>
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
2444: e0682003 rsb r2, r8, r3
2448: e1a02102 lsl r2, r2, #2
244c: e0870108 add r0, r7, r8, lsl #2
2450: e3a01000 mov r1, #0
2454: eb0041ae bl 12b14 <memset>
disktab [major].minor = table;
2458: e5962004 ldr r2, [r6, #4]
disktab [major].size = new_size;
245c: e59d3000 ldr r3, [sp]
if (table == NULL) {
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab [major].minor = table;
2460: e082a00a add sl, r2, sl
disktab [major].size = new_size;
2464: e58a3004 str r3, [sl, #4]
if (table == NULL) {
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab [major].minor = table;
2468: e7827185 str r7, [r2, r5, lsl #3]
246c: eaffffc4 b 2384 <create_disk+0x50>
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
rtems_disk_device_table *table = disktab;
rtems_device_major_number old_size = disktab_size;
rtems_device_major_number new_size = 2 * old_size;
2470: e1a0a087 lsl sl, r7, #1
if (major >= new_size) {
2474: e150000a cmp r0, sl
new_size = major + 1;
2478: 2285a001 addcs sl, r5, #1
rtems_device_minor_number minor = 0;
rtems_filesystem_split_dev_t(dev, major, minor);
if (major >= disktab_size) {
rtems_disk_device_table *table = disktab;
247c: e5960004 ldr r0, [r6, #4]
if (major >= new_size) {
new_size = major + 1;
}
table = realloc(table, new_size * sizeof(*table));
2480: e1a0118a lsl r1, sl, #3
2484: eb0006df bl 4008 <realloc>
if (table == NULL) {
2488: e2508000 subs r8, r0, #0
248c: 0a000007 beq 24b0 <create_disk+0x17c>
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
2490: e067200a rsb r2, r7, sl <== NOT EXECUTED
2494: e0880187 add r0, r8, r7, lsl #3 <== NOT EXECUTED
2498: e1a02182 lsl r2, r2, #3 <== NOT EXECUTED
249c: e3a01000 mov r1, #0 <== NOT EXECUTED
24a0: eb00419b bl 12b14 <memset> <== NOT EXECUTED
disktab = table;
disktab_size = new_size;
24a4: e586a000 str sl, [r6] <== NOT EXECUTED
if (table == NULL) {
return NULL;
}
memset(table + old_size, 0, (new_size - old_size) * sizeof(*table));
disktab = table;
24a8: e5868004 str r8, [r6, #4] <== NOT EXECUTED
24ac: eaffffab b 2360 <create_disk+0x2c> <== NOT EXECUTED
dd->deleted = false;
*dd_entry = dd;
*dd_ptr = dd;
return RTEMS_SUCCESSFUL;
24b0: e3a0001a mov r0, #26
24b4: eaffffb8 b 239c <create_disk+0x68>
}
}
if (name != NULL) {
if (mknod(alloc_name, 0777 | S_IFBLK, dev) < 0) {
free(alloc_name);
24b8: e1a00008 mov r0, r8 <== NOT EXECUTED
24bc: eb00030f bl 3100 <free> <== NOT EXECUTED
free(dd);
24c0: e1a00007 mov r0, r7 <== NOT EXECUTED
24c4: eb00030d bl 3100 <free> <== NOT EXECUTED
24c8: e3a0000d mov r0, #13 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
24cc: eaffffb2 b 239c <create_disk+0x68> <== NOT EXECUTED
if (name != NULL) {
alloc_name = strdup(name);
if (alloc_name == NULL) {
free(dd);
24d0: e1a00007 mov r0, r7 <== NOT EXECUTED
24d4: eb000309 bl 3100 <free> <== NOT EXECUTED
24d8: e3a0001a mov r0, #26 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
24dc: eaffffae b 239c <create_disk+0x68> <== NOT EXECUTED
000088f0 <devFS_evaluate_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
88f0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
88f4: e3d2a007 bics sl, r2, #7
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
88f8: e1a09000 mov r9, r0
88fc: e1a04001 mov r4, r1
8900: e1a0b003 mov fp, r3
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
8904: 1a000028 bne 89ac <devFS_evaluate_path+0xbc>
rtems_set_errno_and_return_minus_one( EPERM );
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
8908: e5937000 ldr r7, [r3]
if (!device_name_table)
890c: e3570000 cmp r7, #0
8910: 0a00002a beq 89c0 <devFS_evaluate_path+0xd0>
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
8914: e59f30b8 ldr r3, [pc, #184] ; 89d4 <devFS_evaluate_path+0xe4>
8918: e5938000 ldr r8, [r3]
891c: e3580000 cmp r8, #0
rtems_set_errno_and_return_minus_one( EPERM );
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
8920: 11a0500a movne r5, sl
for (i = 0; i < rtems_device_table_size; i++) {
8924: 0a000011 beq 8970 <devFS_evaluate_path+0x80>
if (!device_name_table[i].device_name)
8928: e08aa10a add sl, sl, sl, lsl #2
892c: e797610a ldr r6, [r7, sl, lsl #2]
8930: e3560000 cmp r6, #0
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
8934: e1a00009 mov r0, r9
8938: e1a02004 mov r2, r4
893c: e1a01006 mov r1, r6
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
8940: e2855001 add r5, r5, #1
if (!device_name_table[i].device_name)
8944: e087a10a add sl, r7, sl, lsl #2
8948: 0a000005 beq 8964 <devFS_evaluate_path+0x74>
continue;
if (strncmp(pathname, device_name_table[i].device_name, pathnamelen) != 0)
894c: eb000a3e bl b24c <strncmp>
8950: e3500000 cmp r0, #0
8954: 1a000002 bne 8964 <devFS_evaluate_path+0x74>
continue;
if (device_name_table[i].device_name[pathnamelen] != '\0')
8958: e7d60004 ldrb r0, [r6, r4]
895c: e3500000 cmp r0, #0
8960: 0a000007 beq 8984 <devFS_evaluate_path+0x94>
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (i = 0; i < rtems_device_table_size; i++) {
8964: e1580005 cmp r8, r5
8968: e1a0a005 mov sl, r5
896c: 8affffed bhi 8928 <devFS_evaluate_path+0x38>
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
}
/* no such file or directory */
rtems_set_errno_and_return_minus_one( ENOENT );
8970: eb00067f bl a374 <__errno>
8974: e3a03002 mov r3, #2
8978: e5803000 str r3, [r0]
897c: e3e00000 mvn r0, #0
}
8980: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
8984: e59f304c ldr r3, [pc, #76] ; 89d8 <devFS_evaluate_path+0xe8>
8988: e5933000 ldr r3, [r3]
898c: e5933028 ldr r3, [r3, #40] ; 0x28
8990: e58b3010 str r3, [fp, #16]
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
pathloc->handlers = &devFS_file_handlers;
8994: e59f3040 ldr r3, [pc, #64] ; 89dc <devFS_evaluate_path+0xec>
8998: e58b3008 str r3, [fp, #8]
pathloc->ops = &devFS_ops;
899c: e59f303c ldr r3, [pc, #60] ; 89e0 <devFS_evaluate_path+0xf0>
if (device_name_table[i].device_name[pathnamelen] != '\0')
continue;
/* find the device, set proper values */
pathloc->node_access = (void *)&device_name_table[i];
89a0: e58ba000 str sl, [fp]
pathloc->handlers = &devFS_file_handlers;
pathloc->ops = &devFS_ops;
89a4: e58b300c str r3, [fp, #12]
pathloc->mt_entry = rtems_filesystem_root.mt_entry;
return 0;
89a8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
int i;
rtems_device_name_t *device_name_table;
/* see if 'flags' is valid */
if ( !rtems_libio_is_valid_perms( flags ) )
rtems_set_errno_and_return_minus_one( EPERM );
89ac: eb000670 bl a374 <__errno> <== NOT EXECUTED
89b0: e3a03001 mov r3, #1 <== NOT EXECUTED
89b4: e5803000 str r3, [r0] <== NOT EXECUTED
89b8: e3e00000 mvn r0, #0 <== NOT EXECUTED
89bc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/* get the device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
89c0: eb00066b bl a374 <__errno> <== NOT EXECUTED
89c4: e3a0300e mov r3, #14 <== NOT EXECUTED
89c8: e5803000 str r3, [r0] <== NOT EXECUTED
89cc: e3e00000 mvn r0, #0 <== NOT EXECUTED
89d0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0000137c <devFS_initialize>:
int devFS_initialize(
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const void *data
)
{
137c: e92d4070 push {r4, r5, r6, lr}
rtems_device_name_t *device_name_table;
/* allocate device only filesystem name table */
device_name_table = (rtems_device_name_t *)_Workspace_Allocate(
1380: e59f605c ldr r6, [pc, #92] ; 13e4 <devFS_initialize+0x68>
1384: e5963000 ldr r3, [r6]
1388: e0833103 add r3, r3, r3, lsl #2
int devFS_initialize(
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const void *data
)
{
138c: e1a04000 mov r4, r0
rtems_device_name_t *device_name_table;
/* allocate device only filesystem name table */
device_name_table = (rtems_device_name_t *)_Workspace_Allocate(
1390: e1a00103 lsl r0, r3, #2
1394: eb001c25 bl 8430 <_Workspace_Allocate>
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* no memory for device filesystem */
if (!device_name_table)
1398: e2505000 subs r5, r0, #0
139c: 0a00000b beq 13d0 <devFS_initialize+0x54>
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(
13a0: e5962000 ldr r2, [r6]
13a4: e0822102 add r2, r2, r2, lsl #2
13a8: e1a02102 lsl r2, r2, #2
13ac: e3a01000 mov r1, #0
13b0: eb00261d bl ac2c <memset>
device_name_table, 0,
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* set file handlers */
temp_mt_entry->mt_fs_root.handlers = &devFS_file_handlers;
13b4: e59f302c ldr r3, [pc, #44] ; 13e8 <devFS_initialize+0x6c>
temp_mt_entry->mt_fs_root.ops = &devFS_ops;
13b8: e2832038 add r2, r3, #56 ; 0x38
/* Set the node_access to device name table */
temp_mt_entry->mt_fs_root.node_access = (void *)device_name_table;
13bc: e584501c str r5, [r4, #28]
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* set file handlers */
temp_mt_entry->mt_fs_root.handlers = &devFS_file_handlers;
temp_mt_entry->mt_fs_root.ops = &devFS_ops;
13c0: e5842028 str r2, [r4, #40] ; 0x28
device_name_table, 0,
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* set file handlers */
temp_mt_entry->mt_fs_root.handlers = &devFS_file_handlers;
13c4: e5843024 str r3, [r4, #36] ; 0x24
temp_mt_entry->mt_fs_root.ops = &devFS_ops;
/* Set the node_access to device name table */
temp_mt_entry->mt_fs_root.node_access = (void *)device_name_table;
13c8: e3a00000 mov r0, #0
return 0;
}
13cc: e8bd8070 pop {r4, r5, r6, pc}
sizeof( rtems_device_name_t ) * ( rtems_device_table_size )
);
/* no memory for device filesystem */
if (!device_name_table)
rtems_set_errno_and_return_minus_one( ENOMEM );
13d0: eb0023e7 bl a374 <__errno> <== NOT EXECUTED
13d4: e3a0300c mov r3, #12 <== NOT EXECUTED
13d8: e5803000 str r3, [r0] <== NOT EXECUTED
13dc: e3e00000 mvn r0, #0 <== NOT EXECUTED
13e0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00001558 <devFS_ioctl>:
int devFS_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
1558: e52de004 push {lr} ; (str lr, [sp, #-4]!)
155c: e24dd010 sub sp, sp, #16
1560: e1a03000 mov r3, r0
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->file_info;
args.iop = iop;
args.command = command;
1564: e58d1004 str r1, [sp, #4]
{
rtems_libio_ioctl_args_t args;
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->file_info;
1568: e5900038 ldr r0, [r0, #56] ; 0x38
args.iop = iop;
args.command = command;
args.buffer = buffer;
156c: e58d2008 str r2, [sp, #8]
status = rtems_io_control(
1570: e590100c ldr r1, [r0, #12]
1574: e1a0200d mov r2, sp
1578: e5900008 ldr r0, [r0, #8]
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->file_info;
args.iop = iop;
157c: e58d3000 str r3, [sp]
args.command = command;
args.buffer = buffer;
status = rtems_io_control(
1580: eb00107d bl 577c <rtems_io_control>
np->major,
np->minor,
(void *) &args
);
if ( status )
1584: e3500000 cmp r0, #0
return rtems_deviceio_errno(status);
return args.ioctl_return;
1588: 059d000c ldreq r0, [sp, #12]
np->major,
np->minor,
(void *) &args
);
if ( status )
158c: 1a000001 bne 1598 <devFS_ioctl+0x40>
return rtems_deviceio_errno(status);
return args.ioctl_return;
}
1590: e28dd010 add sp, sp, #16
1594: e8bd8000 pop {pc}
np->minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
1598: eb001d11 bl 89e4 <rtems_deviceio_errno> <== NOT EXECUTED
159c: eafffffb b 1590 <devFS_ioctl+0x38> <== NOT EXECUTED
000013ec <devFS_mknod>:
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
13ec: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
13f0: e1a04000 mov r4, r0
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
13f4: e5d00000 ldrb r0, [r0]
13f8: e3500064 cmp r0, #100 ; 0x64
const char *path,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
13fc: e1a05001 mov r5, r1
1400: e1a06002 mov r6, r2
1404: e1a0b003 mov fp, r3
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
1408: 0a000036 beq 14e8 <devFS_mknod+0xfc>
(path[2] == 'v') && (path[3] == '\0'))
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
140c: e2053a0f and r3, r5, #61440 ; 0xf000
1410: e3530a02 cmp r3, #8192 ; 0x2000
1414: 13530a06 cmpne r3, #24576 ; 0x6000
1418: 03a03000 moveq r3, #0
141c: 13a03001 movne r3, #1
1420: 1a00003a bne 1510 <devFS_mknod+0x124>
rtems_set_errno_and_return_minus_one( EINVAL );
else
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
1424: e59d2024 ldr r2, [sp, #36] ; 0x24
1428: e5928000 ldr r8, [r2]
if (!device_name_table)
142c: e3580000 cmp r8, #0
1430: 0a000040 beq 1538 <devFS_mknod+0x14c>
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
1434: e59f2110 ldr r2, [pc, #272] ; 154c <devFS_mknod+0x160>
1438: e592a000 ldr sl, [r2]
143c: e35a0000 cmp sl, #0
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
1440: 13e09000 mvnne r9, #0
1444: 11a07003 movne r7, r3
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
1448: 1a000007 bne 146c <devFS_mknod+0x80>
144c: ea000034 b 1524 <devFS_mknod+0x138> <== NOT EXECUTED
if (device_name_table[i].device_name == NULL)
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
1450: eb00269d bl aecc <strcmp> <== NOT EXECUTED
1454: e3500000 cmp r0, #0 <== NOT EXECUTED
1458: 0a00001d beq 14d4 <devFS_mknod+0xe8> <== NOT EXECUTED
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
145c: e2877001 add r7, r7, #1 <== NOT EXECUTED
1460: e157000a cmp r7, sl <== NOT EXECUTED
1464: e1a03007 mov r3, r7 <== NOT EXECUTED
1468: 2a000009 bcs 1494 <devFS_mknod+0xa8> <== NOT EXECUTED
if (device_name_table[i].device_name == NULL)
146c: e0833103 add r3, r3, r3, lsl #2
1470: e7983103 ldr r3, [r8, r3, lsl #2]
1474: e2531000 subs r1, r3, #0
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
1478: e1a00004 mov r0, r4
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
147c: 1afffff3 bne 1450 <devFS_mknod+0x64>
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
1480: e1a09007 mov r9, r7
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
1484: e2877001 add r7, r7, #1
1488: e157000a cmp r7, sl
148c: e1a03007 mov r3, r7
1490: 3afffff5 bcc 146c <devFS_mknod+0x80>
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
1494: e3790001 cmn r9, #1
1498: 0a000021 beq 1524 <devFS_mknod+0x138>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
149c: e10f7000 mrs r7, CPSR
14a0: e3873080 orr r3, r7, #128 ; 0x80
14a4: e129f003 msr CPSR_fc, r3
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
14a8: e0899109 add r9, r9, r9, lsl #2
14ac: e1a09109 lsl r9, r9, #2
14b0: e7884009 str r4, [r8, r9]
device_name_table[slot].device_name_length = strlen(path);
14b4: e1a00004 mov r0, r4
14b8: eb00274b bl b1ec <strlen>
if (slot == -1)
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
14bc: e0888009 add r8, r8, r9
device_name_table[slot].device_name_length = strlen(path); device_name_table[slot].major = major; device_name_table[slot].minor = minor; device_name_table[slot].mode = mode;
14c0: e5885010 str r5, [r8, #16]
if (slot == -1)
rtems_set_errno_and_return_minus_one( ENOMEM );
_ISR_Disable(level);
device_name_table[slot].device_name = (char *)path;
device_name_table[slot].device_name_length = strlen(path);
14c4: e9880841 stmib r8, {r0, r6, fp}
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
14c8: e129f007 msr CPSR_fc, r7
14cc: e3a00000 mov r0, #0
device_name_table[slot].minor = minor;
device_name_table[slot].mode = mode;
_ISR_Enable(level);
return 0;
}
14d0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
for (slot = -1, i = 0; i < rtems_device_table_size; i++){
if (device_name_table[i].device_name == NULL)
slot = i;
else
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
14d4: eb0023a6 bl a374 <__errno> <== NOT EXECUTED
14d8: e3a03011 mov r3, #17 <== NOT EXECUTED
14dc: e5803000 str r3, [r0] <== NOT EXECUTED
14e0: e3e00000 mvn r0, #0 <== NOT EXECUTED
14e4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* condition and do not create the '/dev' and the 'path'
* actually passed in is 'dev', not '/dev'. Just return 0 to
* indicate we are OK.
*/
if ((path[0] == 'd') && (path[1] == 'e') &&
14e8: e5d43001 ldrb r3, [r4, #1]
14ec: e3530065 cmp r3, #101 ; 0x65
14f0: 1affffc5 bne 140c <devFS_mknod+0x20>
(path[2] == 'v') && (path[3] == '\0'))
14f4: e5d43002 ldrb r3, [r4, #2]
14f8: e3530076 cmp r3, #118 ; 0x76
14fc: 1affffc2 bne 140c <devFS_mknod+0x20>
1500: e5d40003 ldrb r0, [r4, #3]
1504: e3500000 cmp r0, #0
1508: 1affffbf bne 140c <devFS_mknod+0x20>
150c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
return 0;
/* must be a character device or a block device */
if (!S_ISBLK(mode) && !S_ISCHR(mode))
rtems_set_errno_and_return_minus_one( EINVAL );
1510: eb002397 bl a374 <__errno> <== NOT EXECUTED
1514: e3a03016 mov r3, #22 <== NOT EXECUTED
1518: e5803000 str r3, [r0] <== NOT EXECUTED
151c: e3e00000 mvn r0, #0 <== NOT EXECUTED
1520: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (strcmp(path, device_name_table[i].device_name) == 0)
rtems_set_errno_and_return_minus_one( EEXIST );
}
if (slot == -1)
rtems_set_errno_and_return_minus_one( ENOMEM );
1524: eb002392 bl a374 <__errno> <== NOT EXECUTED
1528: e3a0300c mov r3, #12 <== NOT EXECUTED
152c: e5803000 str r3, [r0] <== NOT EXECUTED
1530: e3e00000 mvn r0, #0 <== NOT EXECUTED
1534: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rtems_filesystem_split_dev_t(dev, major, minor);
/* Find an empty slot in device name table */
device_name_table = (rtems_device_name_t *)pathloc->node_access;
if (!device_name_table)
rtems_set_errno_and_return_minus_one( EFAULT );
1538: eb00238d bl a374 <__errno> <== NOT EXECUTED
153c: e3a0300e mov r3, #14 <== NOT EXECUTED
1540: e5803000 str r3, [r0] <== NOT EXECUTED
1544: e3e00000 mvn r0, #0 <== NOT EXECUTED
1548: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
000015e0 <devFS_read>:
ssize_t devFS_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
15e0: e92d4800 push {fp, lr} <== NOT EXECUTED
15e4: e1a03000 mov r3, r0 <== NOT EXECUTED
15e8: e24dd01c sub sp, sp, #28 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
15ec: e5900014 ldr r0, [r0, #20] <== NOT EXECUTED
np = (rtems_device_name_t *)iop->file_info;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
15f0: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
args.flags = iop->flags; args.bytes_moved = 0;
15f4: e3a02000 mov r2, #0 <== NOT EXECUTED
15f8: e58d2018 str r2, [sp, #24] <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
15fc: e58d0014 str r0, [sp, #20] <== NOT EXECUTED
{
rtems_libio_rw_args_t args;
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->file_info;
1600: e5932038 ldr r2, [r3, #56] ; 0x38 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
1604: e283c00c add ip, r3, #12 <== NOT EXECUTED
1608: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
args.buffer = buffer;
160c: e58d100c str r1, [sp, #12] <== NOT EXECUTED
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
1610: e2820008 add r0, r2, #8 <== NOT EXECUTED
1614: e8900003 ldm r0, {r0, r1} <== NOT EXECUTED
1618: e1a0200d mov r2, sp <== NOT EXECUTED
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->file_info;
args.iop = iop;
args.offset = iop->offset;
161c: e98d1800 stmib sp, {fp, ip} <== NOT EXECUTED
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->file_info;
args.iop = iop;
1620: e58d3000 str r3, [sp] <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
1624: eb0010b6 bl 5904 <rtems_io_read> <== NOT EXECUTED
np->major,
np->minor,
(void *) &args
);
if ( status )
1628: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
162c: 059d0018 ldreq r0, [sp, #24] <== NOT EXECUTED
np->major,
np->minor,
(void *) &args
);
if ( status )
1630: 1a000001 bne 163c <devFS_read+0x5c> <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
}
1634: e28dd01c add sp, sp, #28 <== NOT EXECUTED
1638: e8bd8800 pop {fp, pc} <== NOT EXECUTED
np->minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
163c: eb001ce8 bl 89e4 <rtems_deviceio_errno> <== NOT EXECUTED
1640: eafffffb b 1634 <devFS_read+0x54> <== NOT EXECUTED
00001644 <devFS_stat>:
struct stat *buf
)
{
rtems_device_name_t *the_dev;
the_dev = (rtems_device_name_t *)loc->node_access;
1644: e5903000 ldr r3, [r0]
if (!the_dev)
1648: e3530000 cmp r3, #0
int devFS_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
164c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_device_name_t *the_dev;
the_dev = (rtems_device_name_t *)loc->node_access;
if (!the_dev)
1650: 0a000007 beq 1674 <devFS_stat+0x30>
rtems_set_errno_and_return_minus_one( EFAULT );
buf->st_rdev = rtems_filesystem_make_dev_t( the_dev->major, the_dev->minor );
buf->st_mode = the_dev->mode;
1654: e5930010 ldr r0, [r3, #16]
the_dev = (rtems_device_name_t *)loc->node_access;
if (!the_dev)
rtems_set_errno_and_return_minus_one( EFAULT );
buf->st_rdev = rtems_filesystem_make_dev_t( the_dev->major, the_dev->minor );
1658: e593200c ldr r2, [r3, #12]
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
165c: e5933008 ldr r3, [r3, #8]
1660: e581201c str r2, [r1, #28]
buf->st_mode = the_dev->mode;
1664: e581000c str r0, [r1, #12]
the_dev = (rtems_device_name_t *)loc->node_access;
if (!the_dev)
rtems_set_errno_and_return_minus_one( EFAULT );
buf->st_rdev = rtems_filesystem_make_dev_t( the_dev->major, the_dev->minor );
1668: e5813018 str r3, [r1, #24]
buf->st_mode = the_dev->mode;
166c: e3a00000 mov r0, #0
return 0;
}
1670: e49df004 pop {pc} ; (ldr pc, [sp], #4)
{
rtems_device_name_t *the_dev;
the_dev = (rtems_device_name_t *)loc->node_access;
if (!the_dev)
rtems_set_errno_and_return_minus_one( EFAULT );
1674: eb00233e bl a374 <__errno> <== NOT EXECUTED
1678: e3a0300e mov r3, #14 <== NOT EXECUTED
167c: e5803000 str r3, [r0] <== NOT EXECUTED
1680: e3e00000 mvn r0, #0 <== NOT EXECUTED
1684: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00001688 <devFS_write>:
ssize_t devFS_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
1688: e92d4800 push {fp, lr}
168c: e1a03000 mov r3, r0
1690: e24dd01c sub sp, sp, #28
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
1694: e5900014 ldr r0, [r0, #20]
np = (rtems_device_name_t *)iop->file_info;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
1698: e58d2010 str r2, [sp, #16]
args.flags = iop->flags; args.bytes_moved = 0;
169c: e3a02000 mov r2, #0
16a0: e58d2018 str r2, [sp, #24]
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
16a4: e58d0014 str r0, [sp, #20]
{
rtems_libio_rw_args_t args;
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->file_info;
16a8: e5932038 ldr r2, [r3, #56] ; 0x38
args.iop = iop;
args.offset = iop->offset;
16ac: e283c00c add ip, r3, #12
16b0: e89c1800 ldm ip, {fp, ip}
args.buffer = (void *) buffer;
16b4: e58d100c str r1, [sp, #12]
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write(
16b8: e2820008 add r0, r2, #8
16bc: e8900003 ldm r0, {r0, r1}
16c0: e1a0200d mov r2, sp
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->file_info;
args.iop = iop;
args.offset = iop->offset;
16c4: e98d1800 stmib sp, {fp, ip}
rtems_status_code status;
rtems_device_name_t *np;
np = (rtems_device_name_t *)iop->file_info;
args.iop = iop;
16c8: e58d3000 str r3, [sp]
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write(
16cc: eb0010a0 bl 5954 <rtems_io_write>
np->major,
np->minor,
(void *) &args
);
if ( status )
16d0: e3500000 cmp r0, #0
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
16d4: 059d0018 ldreq r0, [sp, #24]
np->major,
np->minor,
(void *) &args
);
if ( status )
16d8: 1a000001 bne 16e4 <devFS_write+0x5c>
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
}
16dc: e28dd01c add sp, sp, #28
16e0: e8bd8800 pop {fp, pc}
np->minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
16e4: eb001cbe bl 89e4 <rtems_deviceio_errno> <== NOT EXECUTED
16e8: eafffffb b 16dc <devFS_write+0x54> <== NOT EXECUTED
0000d4d0 <device_ioctl>:
int device_ioctl(
rtems_libio_t *iop,
uint32_t command,
void *buffer
)
{
d4d0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
d4d4: e24dd010 sub sp, sp, #16
rtems_status_code status;
IMFS_jnode_t *the_jnode;
args.iop = iop;
args.command = command;
args.buffer = buffer;
d4d8: e88d0007 stm sp, {r0, r1, r2}
the_jnode = iop->file_info;
d4dc: e5903038 ldr r3, [r0, #56] ; 0x38
status = rtems_io_control(
d4e0: e1a0200d mov r2, sp
d4e4: e2830050 add r0, r3, #80 ; 0x50
d4e8: e8900003 ldm r0, {r0, r1}
d4ec: eb000292 bl df3c <rtems_io_control>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
d4f0: e3500000 cmp r0, #0
return rtems_deviceio_errno(status);
return args.ioctl_return;
d4f4: 059d000c ldreq r0, [sp, #12]
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
d4f8: 1a000001 bne d504 <device_ioctl+0x34>
return rtems_deviceio_errno(status);
return args.ioctl_return;
}
d4fc: e28dd010 add sp, sp, #16
d500: e8bd8000 pop {pc}
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
d504: eb000337 bl e1e8 <rtems_deviceio_errno> <== NOT EXECUTED
d508: eafffffb b d4fc <device_ioctl+0x2c> <== NOT EXECUTED
0000d56c <device_read>:
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
d56c: e92d4800 push {fp, lr}
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
d570: e5903014 ldr r3, [r0, #20]
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
d574: e280c00c add ip, r0, #12
d578: e89c1800 ldm ip, {fp, ip}
ssize_t device_read(
rtems_libio_t *iop,
void *buffer,
size_t count
)
{
d57c: e24dd01c sub sp, sp, #28
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
d580: e58d3014 str r3, [sp, #20]
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
d584: e98d1800 stmib sp, {fp, ip}
args.buffer = buffer; args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
d588: e3a03000 mov r3, #0
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
d58c: e58d2010 str r2, [sp, #16]
args.flags = iop->flags; args.bytes_moved = 0;
d590: e58d3018 str r3, [sp, #24]
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
d594: e58d100c str r1, [sp, #12]
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
d598: e58d0000 str r0, [sp]
{
rtems_libio_rw_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
d59c: e5903038 ldr r3, [r0, #56] ; 0x38
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read(
d5a0: e1a0200d mov r2, sp
d5a4: e2830050 add r0, r3, #80 ; 0x50
d5a8: e8900003 ldm r0, {r0, r1}
d5ac: eb00028a bl dfdc <rtems_io_read>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
d5b0: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
d5b4: 059d0018 ldreq r0, [sp, #24] <== NOT EXECUTED
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
d5b8: 1a000001 bne d5c4 <device_read+0x58> <== NOT EXECUTED
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
}
d5bc: e28dd01c add sp, sp, #28 <== NOT EXECUTED
d5c0: e8bd8800 pop {fp, pc} <== NOT EXECUTED
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
d5c4: eb000307 bl e1e8 <rtems_deviceio_errno> <== NOT EXECUTED
d5c8: eafffffb b d5bc <device_read+0x50> <== NOT EXECUTED
0000d50c <device_write>:
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
d50c: e92d4800 push {fp, lr}
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
d510: e5903014 ldr r3, [r0, #20]
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
d514: e280c00c add ip, r0, #12
d518: e89c1800 ldm ip, {fp, ip}
ssize_t device_write(
rtems_libio_t *iop,
const void *buffer,
size_t count
)
{
d51c: e24dd01c sub sp, sp, #28
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
d520: e58d3014 str r3, [sp, #20]
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
d524: e98d1800 stmib sp, {fp, ip}
args.buffer = (void *) buffer; args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
d528: e3a03000 mov r3, #0
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
d52c: e58d2010 str r2, [sp, #16]
args.flags = iop->flags; args.bytes_moved = 0;
d530: e58d3018 str r3, [sp, #24]
the_jnode = iop->file_info;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
d534: e58d100c str r1, [sp, #12]
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
args.iop = iop;
d538: e58d0000 str r0, [sp]
{
rtems_libio_rw_args_t args;
rtems_status_code status;
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
d53c: e5903038 ldr r3, [r0, #56] ; 0x38
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write(
d540: e1a0200d mov r2, sp
d544: e2830050 add r0, r3, #80 ; 0x50
d548: e8900003 ldm r0, {r0, r1}
d54c: eb0002b6 bl e02c <rtems_io_write>
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
d550: e3500000 cmp r0, #0
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
d554: 059d0018 ldreq r0, [sp, #24]
the_jnode->info.device.major,
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
d558: 1a000001 bne d564 <device_write+0x58>
return rtems_deviceio_errno(status);
return (ssize_t) args.bytes_moved;
}
d55c: e28dd01c add sp, sp, #28
d560: e8bd8800 pop {fp, pc}
the_jnode->info.device.minor,
(void *) &args
);
if ( status )
return rtems_deviceio_errno(status);
d564: eb00031f bl e1e8 <rtems_deviceio_errno> <== NOT EXECUTED
d568: eafffffb b d55c <device_write+0x50> <== NOT EXECUTED
00001f6c <disk_unlock>:
static void
disk_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
1f6c: e59f3028 ldr r3, [pc, #40] ; 1f9c <disk_unlock+0x30>
1f70: e3a02000 mov r2, #0
}
}
static void
disk_unlock(void)
{
1f74: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
sc = rtems_semaphore_release(diskdevs_mutex);
1f78: e5930008 ldr r0, [r3, #8]
static void
disk_unlock(void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
diskdevs_protected = false;
1f7c: e5c3200c strb r2, [r3, #12]
sc = rtems_semaphore_release(diskdevs_mutex);
1f80: eb00132c bl 6c38 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL) {
1f84: e3500000 cmp r0, #0
1f88: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
/* FIXME: Error number */
rtems_fatal_error_occurred(0xdeadbeef);
1f8c: e3e00585 mvn r0, #557842432 ; 0x21400000 <== NOT EXECUTED
1f90: e2400949 sub r0, r0, #1196032 ; 0x124000 <== NOT EXECUTED
1f94: e2400e11 sub r0, r0, #272 ; 0x110 <== NOT EXECUTED
1f98: eb001456 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
00003e2c <drainOutput>:
drainOutput (struct rtems_termios_tty *tty)
{
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
3e2c: e59030b4 ldr r3, [r0, #180] ; 0xb4
3e30: e3530000 cmp r3, #0
/*
* Drain output queue
*/
static void
drainOutput (struct rtems_termios_tty *tty)
{
3e34: e92d4030 push {r4, r5, lr}
3e38: e1a04000 mov r4, r0
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
3e3c: 08bd8030 popeq {r4, r5, pc}
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
3e40: e10f3000 mrs r3, CPSR <== NOT EXECUTED
3e44: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
3e48: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
3e4c: e5901084 ldr r1, [r0, #132] ; 0x84 <== NOT EXECUTED
3e50: e5902080 ldr r2, [r0, #128] ; 0x80 <== NOT EXECUTED
3e54: e1510002 cmp r1, r2 <== NOT EXECUTED
3e58: 0a00000f beq 3e9c <drainOutput+0x70> <== NOT EXECUTED
tty->rawOutBufState = rob_wait;
3e5c: e3a05002 mov r5, #2 <== NOT EXECUTED
3e60: e5845094 str r5, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3e64: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable (level); sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
3e68: e3a01000 mov r1, #0 <== NOT EXECUTED
3e6c: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED
3e70: e1a02001 mov r2, r1 <== NOT EXECUTED
3e74: eb00064c bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL)
3e78: e3500000 cmp r0, #0 <== NOT EXECUTED
3e7c: 1a000008 bne 3ea4 <drainOutput+0x78> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
3e80: e10f3000 mrs r3, CPSR <== NOT EXECUTED
3e84: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
3e88: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts != TERMIOS_POLLED) {
rtems_interrupt_disable (level);
while (tty->rawOutBuf.Tail != tty->rawOutBuf.Head) {
3e8c: e5941084 ldr r1, [r4, #132] ; 0x84 <== NOT EXECUTED
3e90: e5942080 ldr r2, [r4, #128] ; 0x80 <== NOT EXECUTED
3e94: e1510002 cmp r1, r2 <== NOT EXECUTED
3e98: 1afffff0 bne 3e60 <drainOutput+0x34> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3e9c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
3ea0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
rtems_interrupt_enable (level); sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc);
3ea4: eb0007cd bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000279c <dup2>:
int dup2(
int fildes,
int fildes2
)
{
279c: e92d4070 push {r4, r5, r6, lr}
27a0: e24dd048 sub sp, sp, #72 ; 0x48
27a4: e1a05001 mov r5, r1
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
27a8: e1a0100d mov r1, sp
int dup2(
int fildes,
int fildes2
)
{
27ac: e1a06000 mov r6, r0
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
27b0: eb00019c bl 2e28 <fstat>
if ( status == -1 )
27b4: e3700001 cmn r0, #1
/*
* If fildes is not valid, then fildes2 should not be closed.
*/
status = fstat( fildes, &buf );
27b8: e1a0400d mov r4, sp
if ( status == -1 )
27bc: 1a000002 bne 27cc <dup2+0x30>
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
27c0: e3e00000 mvn r0, #0
}
27c4: e28dd048 add sp, sp, #72 ; 0x48
27c8: e8bd8070 pop {r4, r5, r6, pc}
/*
* If fildes2 is not valid, then we should not do anything either.
*/
status = fstat( fildes2, &buf );
27cc: e1a0100d mov r1, sp
27d0: e1a00005 mov r0, r5
27d4: eb000193 bl 2e28 <fstat>
if ( status == -1 )
27d8: e3700001 cmn r0, #1
27dc: 0afffff7 beq 27c0 <dup2+0x24>
/*
* This fcntl handles everything else.
*/
return fcntl( fildes, F_DUPFD, fildes2 );
27e0: e1a00006 mov r0, r6 <== NOT EXECUTED
27e4: e1a02005 mov r2, r5 <== NOT EXECUTED
27e8: e3a01000 mov r1, #0 <== NOT EXECUTED
27ec: eb000087 bl 2a10 <fcntl> <== NOT EXECUTED
27f0: eafffff3 b 27c4 <dup2+0x28> <== NOT EXECUTED
0000389c <echo>:
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
389c: e92d4010 push {r4, lr} <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
38a0: e591303c ldr r3, [r1, #60] ; 0x3c <== NOT EXECUTED
38a4: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
/*
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
38a8: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
38ac: e1a04001 mov r4, r1 <== NOT EXECUTED
38b0: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
38b4: 0a000007 beq 38d8 <echo+0x3c> <== NOT EXECUTED
38b8: e59f3060 ldr r3, [pc, #96] ; 3920 <echo+0x84> <== NOT EXECUTED
38bc: e5933000 ldr r3, [r3] <== NOT EXECUTED
38c0: e0833000 add r3, r3, r0 <== NOT EXECUTED
38c4: e5d32001 ldrb r2, [r3, #1] <== NOT EXECUTED
38c8: e2503009 subs r3, r0, #9 <== NOT EXECUTED
38cc: 13a03001 movne r3, #1 <== NOT EXECUTED
38d0: e01332a2 ands r3, r3, r2, lsr #5 <== NOT EXECUTED
38d4: 1a000003 bne 38e8 <echo+0x4c> <== NOT EXECUTED
echobuf[1] = c ^ 0x40;
rtems_termios_puts (echobuf, 2, tty);
tty->column += 2;
}
else {
oproc (c, tty);
38d8: e1a01004 mov r1, r4 <== NOT EXECUTED
38dc: ebffff92 bl 372c <oproc> <== NOT EXECUTED
} }
38e0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
38e4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
38e8: e350000a cmp r0, #10 <== NOT EXECUTED
38ec: 0afffff9 beq 38d8 <echo+0x3c> <== NOT EXECUTED
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
38f0: e2203040 eor r3, r0, #64 ; 0x40 <== NOT EXECUTED
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
38f4: e3a0c05e mov ip, #94 ; 0x5e <== NOT EXECUTED
echobuf[1] = c ^ 0x40; rtems_termios_puts (echobuf, 2, tty);
38f8: e1a0000d mov r0, sp <== NOT EXECUTED
38fc: e3a01002 mov r1, #2 <== NOT EXECUTED
3900: e1a02004 mov r2, r4 <== NOT EXECUTED
{
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
echobuf[1] = c ^ 0x40;
3904: e5cd3001 strb r3, [sp, #1] <== NOT EXECUTED
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
char echobuf[2];
echobuf[0] = '^';
3908: e5cdc000 strb ip, [sp] <== NOT EXECUTED
echobuf[1] = c ^ 0x40; rtems_termios_puts (echobuf, 2, tty);
390c: ebffff3e bl 360c <rtems_termios_puts> <== NOT EXECUTED
tty->column += 2;
3910: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
3914: e2833002 add r3, r3, #2 <== NOT EXECUTED
3918: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
* Echo a typed character
*/
static void
echo (unsigned char c, struct rtems_termios_tty *tty)
{
if ((tty->termios.c_lflag & ECHOCTL) && iscntrl(c) && (c != '\t') && (c != '\n')) {
391c: eaffffef b 38e0 <echo+0x44> <== NOT EXECUTED
000291b4 <endgrent>:
group_fp = fopen("/etc/group", "r");
}
void endgrent(void)
{
if (group_fp != NULL)
291b4: e59f300c ldr r3, [pc, #12] ; 291c8 <endgrent+0x14> <== NOT EXECUTED 291b8: e5930000 ldr r0, [r3] <== NOT EXECUTED 291bc: e3500000 cmp r0, #0 <== NOT EXECUTED 291c0: 012fff1e bxeq lr <== NOT EXECUTED
fclose(group_fp);
291c4: ea0067d6 b 43124 <fclose> <== NOT EXECUTED
000291cc <endpwent>:
passwd_fp = fopen("/etc/passwd", "r");
}
void endpwent(void)
{
if (passwd_fp != NULL)
291cc: e59f300c ldr r3, [pc, #12] ; 291e0 <endpwent+0x14> <== NOT EXECUTED 291d0: e5930004 ldr r0, [r3, #4] <== NOT EXECUTED 291d4: e3500000 cmp r0, #0 <== NOT EXECUTED 291d8: 012fff1e bxeq lr <== NOT EXECUTED
fclose(passwd_fp);
291dc: ea0067d0 b 43124 <fclose> <== NOT EXECUTED
00003924 <erase>:
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
3924: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED
3928: e3530000 cmp r3, #0 <== NOT EXECUTED
* FIXME: Needs support for WERASE and ECHOPRT.
* FIXME: Some of the tests should check for IEXTEN, too.
*/
static void
erase (struct rtems_termios_tty *tty, int lineFlag)
{
392c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
3930: e1a04000 mov r4, r0 <== NOT EXECUTED
3934: e1a06001 mov r6, r1 <== NOT EXECUTED
if (tty->ccount == 0)
3938: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return;
if (lineFlag) {
393c: e3510000 cmp r1, #0 <== NOT EXECUTED
3940: 0590203c ldreq r2, [r0, #60] ; 0x3c <== NOT EXECUTED
3944: 1a000025 bne 39e0 <erase+0xbc> <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
3948: e59f71d4 ldr r7, [pc, #468] ; 3b24 <erase+0x200> <== NOT EXECUTED
394c: ea000007 b 3970 <erase+0x4c> <== NOT EXECUTED
3950: e3120c02 tst r2, #512 ; 0x200 <== NOT EXECUTED
3954: 1a00005a bne 3ac4 <erase+0x1a0> <== NOT EXECUTED
if (tty->column) tty->column--; } } } if (!lineFlag)
3958: e3560000 cmp r6, #0 <== NOT EXECUTED
395c: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
3960: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED
3964: e3530000 cmp r3, #0 <== NOT EXECUTED
3968: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
396c: e594203c ldr r2, [r4, #60] ; 0x3c <== NOT EXECUTED
unsigned char c = tty->cbuf[--tty->ccount];
3970: e2433001 sub r3, r3, #1 <== NOT EXECUTED
3974: e5843020 str r3, [r4, #32] <== NOT EXECUTED
3978: e594001c ldr r0, [r4, #28] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
397c: e3120008 tst r2, #8 <== NOT EXECUTED
echo ('\n', tty);
return;
}
}
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
3980: e7d05003 ldrb r5, [r0, r3] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
3984: 0afffff3 beq 3958 <erase+0x34> <== NOT EXECUTED
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
3988: e3560000 cmp r6, #0 <== NOT EXECUTED
398c: 1a000001 bne 3998 <erase+0x74> <== NOT EXECUTED
3990: e3120010 tst r2, #16 <== NOT EXECUTED
3994: 0a000046 beq 3ab4 <erase+0x190> <== NOT EXECUTED
echo (tty->termios.c_cc[VERASE], tty);
}
else if (c == '\t') {
3998: e3550009 cmp r5, #9 <== NOT EXECUTED
399c: 0a000020 beq 3a24 <erase+0x100> <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
39a0: e5973000 ldr r3, [r7] <== NOT EXECUTED
39a4: e2855001 add r5, r5, #1 <== NOT EXECUTED
39a8: e7d33005 ldrb r3, [r3, r5] <== NOT EXECUTED
39ac: e3130020 tst r3, #32 <== NOT EXECUTED
39b0: 1affffe6 bne 3950 <erase+0x2c> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
if (tty->column)
tty->column--;
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
39b4: e59f016c ldr r0, [pc, #364] ; 3b28 <erase+0x204> <== NOT EXECUTED
39b8: e3a01003 mov r1, #3 <== NOT EXECUTED
39bc: e1a02004 mov r2, r4 <== NOT EXECUTED
39c0: ebffff11 bl 360c <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
39c4: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
39c8: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
39cc: 12433001 subne r3, r3, #1 <== NOT EXECUTED
39d0: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
} } } if (!lineFlag)
39d4: e3560000 cmp r6, #0 <== NOT EXECUTED
39d8: 1affffe0 bne 3960 <erase+0x3c> <== NOT EXECUTED
39dc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
39e0: e590203c ldr r2, [r0, #60] ; 0x3c <== NOT EXECUTED
39e4: e2121008 ands r1, r2, #8 <== NOT EXECUTED
tty->ccount = 0;
39e8: 05801020 streq r1, [r0, #32] <== NOT EXECUTED
erase (struct rtems_termios_tty *tty, int lineFlag)
{
if (tty->ccount == 0)
return;
if (lineFlag) {
if (!(tty->termios.c_lflag & ECHO)) {
39ec: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
tty->ccount = 0;
return;
}
if (!(tty->termios.c_lflag & ECHOE)) {
39f0: e2121010 ands r1, r2, #16 <== NOT EXECUTED
39f4: 1affffd3 bne 3948 <erase+0x24> <== NOT EXECUTED
tty->ccount = 0;
39f8: e5801020 str r1, [r0, #32] <== NOT EXECUTED
echo (tty->termios.c_cc[VKILL], tty);
39fc: e5d00044 ldrb r0, [r0, #68] ; 0x44 <== NOT EXECUTED
3a00: e1a01004 mov r1, r4 <== NOT EXECUTED
3a04: ebffffa4 bl 389c <echo> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOK)
3a08: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
3a0c: e3130020 tst r3, #32 <== NOT EXECUTED
3a10: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
echo ('\n', tty);
3a14: e1a01004 mov r1, r4 <== NOT EXECUTED
3a18: e3a0000a mov r0, #10 <== NOT EXECUTED
} } if (!lineFlag) break; } }
3a1c: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
}
if (!(tty->termios.c_lflag & ECHOE)) {
tty->ccount = 0;
echo (tty->termios.c_cc[VKILL], tty);
if (tty->termios.c_lflag & ECHOK)
echo ('\n', tty);
3a20: eaffff9d b 389c <echo> <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
3a24: e3530000 cmp r3, #0 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
}
else if (c == '\t') {
int col = tty->read_start_column;
3a28: e594502c ldr r5, [r4, #44] ; 0x2c <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
3a2c: 0a000011 beq 3a78 <erase+0x154> <== NOT EXECUTED
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
3a30: e5978000 ldr r8, [r7] <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
3a34: e202ac02 and sl, r2, #512 ; 0x200 <== NOT EXECUTED
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
3a38: e3a02000 mov r2, #0 <== NOT EXECUTED
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
3a3c: e7d01002 ldrb r1, [r0, r2] <== NOT EXECUTED
if (c == '\t') {
3a40: e3510009 cmp r1, #9 <== NOT EXECUTED
col = (col | 7) + 1;
3a44: 03855007 orreq r5, r5, #7 <== NOT EXECUTED
}
else if (iscntrl (c)) {
3a48: e088c001 add ip, r8, r1 <== NOT EXECUTED
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
3a4c: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (c == '\t') {
col = (col | 7) + 1;
3a50: 02855001 addeq r5, r5, #1 <== NOT EXECUTED
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
3a54: 0a000005 beq 3a70 <erase+0x14c> <== NOT EXECUTED
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
3a58: e5dc1001 ldrb r1, [ip, #1] <== NOT EXECUTED
3a5c: e3110020 tst r1, #32 <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
col += 2;
}
else {
col++;
3a60: 02855001 addeq r5, r5, #1 <== NOT EXECUTED
while (i != tty->ccount) {
c = tty->cbuf[i++];
if (c == '\t') {
col = (col | 7) + 1;
}
else if (iscntrl (c)) {
3a64: 0a000001 beq 3a70 <erase+0x14c> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHOCTL)
3a68: e35a0000 cmp sl, #0 <== NOT EXECUTED
col += 2;
3a6c: 12855002 addne r5, r5, #2 <== NOT EXECUTED
int i = 0;
/*
* Find the character before the tab
*/
while (i != tty->ccount) {
3a70: e1530002 cmp r3, r2 <== NOT EXECUTED
3a74: 1afffff0 bne 3a3c <erase+0x118> <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
3a78: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
3a7c: e1550003 cmp r5, r3 <== NOT EXECUTED
3a80: aaffffb4 bge 3958 <erase+0x34> <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
3a84: e59f00a0 ldr r0, [pc, #160] ; 3b2c <erase+0x208> <== NOT EXECUTED
3a88: e3a01001 mov r1, #1 <== NOT EXECUTED
3a8c: e1a02004 mov r2, r4 <== NOT EXECUTED
3a90: ebfffedd bl 360c <rtems_termios_puts> <== NOT EXECUTED
tty->column--;
3a94: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
3a98: e2433001 sub r3, r3, #1 <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
3a9c: e1550003 cmp r5, r3 <== NOT EXECUTED
rtems_termios_puts ("\b", 1, tty);
tty->column--;
3aa0: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
/*
* Back up over the tab
*/
while (tty->column > col) {
3aa4: bafffff6 blt 3a84 <erase+0x160> <== NOT EXECUTED
if (tty->column) tty->column--; } } } if (!lineFlag)
3aa8: e3560000 cmp r6, #0 <== NOT EXECUTED
3aac: 1affffab bne 3960 <erase+0x3c> <== NOT EXECUTED
3ab0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
3ab4: e5d40043 ldrb r0, [r4, #67] ; 0x43 <== NOT EXECUTED
3ab8: e1a01004 mov r1, r4 <== NOT EXECUTED
} } if (!lineFlag) break; } }
3abc: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
while (tty->ccount) {
unsigned char c = tty->cbuf[--tty->ccount];
if (tty->termios.c_lflag & ECHO) {
if (!lineFlag && !(tty->termios.c_lflag & ECHOE)) {
echo (tty->termios.c_cc[VERASE], tty);
3ac0: eaffff75 b 389c <echo> <== NOT EXECUTED
tty->column--;
}
}
else {
if (iscntrl (c) && (tty->termios.c_lflag & ECHOCTL)) {
rtems_termios_puts ("\b \b", 3, tty);
3ac4: e59f005c ldr r0, [pc, #92] ; 3b28 <erase+0x204> <== NOT EXECUTED
3ac8: e3a01003 mov r1, #3 <== NOT EXECUTED
3acc: e1a02004 mov r2, r4 <== NOT EXECUTED
3ad0: ebfffecd bl 360c <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
3ad4: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
3ad8: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
3adc: 12433001 subne r3, r3, #1 <== NOT EXECUTED
3ae0: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
}
if (!iscntrl (c) || (tty->termios.c_lflag & ECHOCTL)) {
3ae4: e5973000 ldr r3, [r7] <== NOT EXECUTED
3ae8: e7d33005 ldrb r3, [r3, r5] <== NOT EXECUTED
3aec: e3130020 tst r3, #32 <== NOT EXECUTED
3af0: 0affffaf beq 39b4 <erase+0x90> <== NOT EXECUTED
3af4: e594203c ldr r2, [r4, #60] ; 0x3c <== NOT EXECUTED
3af8: e3120c02 tst r2, #512 ; 0x200 <== NOT EXECUTED
3afc: 0affff95 beq 3958 <erase+0x34> <== NOT EXECUTED
rtems_termios_puts ("\b \b", 3, tty);
3b00: e59f0020 ldr r0, [pc, #32] ; 3b28 <erase+0x204> <== NOT EXECUTED
3b04: e3a01003 mov r1, #3 <== NOT EXECUTED
3b08: e1a02004 mov r2, r4 <== NOT EXECUTED
3b0c: ebfffebe bl 360c <rtems_termios_puts> <== NOT EXECUTED
if (tty->column)
3b10: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
3b14: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
3b18: 12433001 subne r3, r3, #1 <== NOT EXECUTED
3b1c: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
3b20: eaffffab b 39d4 <erase+0xb0> <== NOT EXECUTED
000260fc <fat_buf_access>:
#include "fat_fat_operations.h"
int
fat_buf_access(fat_fs_info_t *fs_info, uint32_t blk, int op_type,
rtems_bdbuf_buffer **buf)
{
260fc: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
26100: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
26104: e5d00081 ldrb r0, [r0, #129] ; 0x81 <== NOT EXECUTED 26108: e3500000 cmp r0, #0 <== NOT EXECUTED
#include "fat_fat_operations.h"
int
fat_buf_access(fat_fs_info_t *fs_info, uint32_t blk, int op_type,
rtems_bdbuf_buffer **buf)
{
2610c: e1a08003 mov r8, r3 <== NOT EXECUTED 26110: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 26114: e1a06001 mov r6, r1 <== NOT EXECUTED 26118: e1a07002 mov r7, r2 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
2611c: 1594307c ldrne r3, [r4, #124] ; 0x7c <== NOT EXECUTED 26120: 1a00000d bne 2615c <fat_buf_access+0x60> <== NOT EXECUTED
{
if (op_type == FAT_OP_TYPE_READ)
26124: e3520001 cmp r2, #1 <== NOT EXECUTED 26128: 0a000062 beq 262b8 <fat_buf_access+0x1bc> <== NOT EXECUTED
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
2612c: e2841054 add r1, r4, #84 ; 0x54 <== NOT EXECUTED
26130: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
26134: e1a02006 mov r2, r6 <== NOT EXECUTED
26138: e2843084 add r3, r4, #132 ; 0x84 <== NOT EXECUTED
2613c: ebff7d39 bl 5628 <rtems_bdbuf_get> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
26140: e3500000 cmp r0, #0 <== NOT EXECUTED 26144: 1a00006d bne 26300 <fat_buf_access+0x204> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
fs_info->c.modified = 0;
fs_info->c.state = FAT_CACHE_ACTUAL;
26148: e3a03001 mov r3, #1 <== NOT EXECUTED
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
fs_info->c.modified = 0;
2614c: e5c40080 strb r0, [r4, #128] ; 0x80 <== NOT EXECUTED
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
26150: e584607c str r6, [r4, #124] ; 0x7c <== NOT EXECUTED
fs_info->c.modified = 0;
fs_info->c.state = FAT_CACHE_ACTUAL;
26154: e5c43081 strb r3, [r4, #129] ; 0x81 <== NOT EXECUTED 26158: e1a03006 mov r3, r6 <== NOT EXECUTED
}
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
2615c: e1d421b4 ldrh r2, [r4, #20] <== NOT EXECUTED 26160: e1520003 cmp r2, r3 <== NOT EXECUTED 26164: 83a05000 movhi r5, #0 <== NOT EXECUTED 26168: 9a00004d bls 262a4 <fat_buf_access+0x1a8> <== NOT EXECUTED
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.blk_num != blk)
2616c: e1560003 cmp r6, r3 <== NOT EXECUTED 26170: 0a000046 beq 26290 <fat_buf_access+0x194> <== NOT EXECUTED
{
if (fs_info->c.modified)
26174: e5d4a080 ldrb sl, [r4, #128] ; 0x80 <== NOT EXECUTED 26178: e35a0000 cmp sl, #0 <== NOT EXECUTED 2617c: 0a000032 beq 2624c <fat_buf_access+0x150> <== NOT EXECUTED
{
if (sec_of_fat && !fs_info->vol.mirror)
26180: e3550000 cmp r5, #0 <== NOT EXECUTED 26184: 0a000002 beq 26194 <fat_buf_access+0x98> <== NOT EXECUTED 26188: e5d43048 ldrb r3, [r4, #72] ; 0x48 <== NOT EXECUTED 2618c: e3530000 cmp r3, #0 <== NOT EXECUTED 26190: 0a00004e beq 262d0 <fat_buf_access+0x1d4> <== NOT EXECUTED
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
26194: e5940084 ldr r0, [r4, #132] ; 0x84 <== NOT EXECUTED 26198: ebff78a3 bl 442c <rtems_bdbuf_release_modified> <== NOT EXECUTED
fs_info->c.state = FAT_CACHE_EMPTY;
2619c: e3a03000 mov r3, #0 <== NOT EXECUTED
fs_info->c.modified = 0;
if (sc != RTEMS_SUCCESSFUL)
261a0: e3500000 cmp r0, #0 <== NOT EXECUTED
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
fs_info->c.state = FAT_CACHE_EMPTY;
fs_info->c.modified = 0;
261a4: e5c43080 strb r3, [r4, #128] ; 0x80 <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
fs_info->c.state = FAT_CACHE_EMPTY;
261a8: e5c43081 strb r3, [r4, #129] ; 0x81 <== NOT EXECUTED
fs_info->c.modified = 0;
if (sc != RTEMS_SUCCESSFUL)
261ac: 1a000053 bne 26300 <fat_buf_access+0x204> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
if (sec_of_fat && !fs_info->vol.mirror)
261b0: e3550000 cmp r5, #0 <== NOT EXECUTED 261b4: 0a000029 beq 26260 <fat_buf_access+0x164> <== NOT EXECUTED 261b8: e5d43048 ldrb r3, [r4, #72] ; 0x48 <== NOT EXECUTED 261bc: e3530000 cmp r3, #0 <== NOT EXECUTED 261c0: 1a000026 bne 26260 <fat_buf_access+0x164> <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
261c4: e5d43009 ldrb r3, [r4, #9] <== NOT EXECUTED 261c8: e3530001 cmp r3, #1 <== NOT EXECUTED 261cc: 9a000023 bls 26260 <fat_buf_access+0x164> <== NOT EXECUTED 261d0: e3a05001 mov r5, #1 <== NOT EXECUTED 261d4: e1a0a00d mov sl, sp <== NOT EXECUTED 261d8: ea00000d b 26214 <fat_buf_access+0x118> <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
261dc: e59d3000 ldr r3, [sp] <== NOT EXECUTED 261e0: e5941088 ldr r1, [r4, #136] ; 0x88 <== NOT EXECUTED 261e4: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 261e8: e1d420b0 ldrh r2, [r4] <== NOT EXECUTED 261ec: eb00802f bl 462b0 <memcpy> <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(b);
261f0: e59d0000 ldr r0, [sp] <== NOT EXECUTED 261f4: ebff788c bl 442c <rtems_bdbuf_release_modified> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
261f8: e2855001 add r5, r5, #1 <== NOT EXECUTED
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(b);
if ( sc != RTEMS_SUCCESSFUL)
261fc: e3500000 cmp r0, #0 <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
26200: e20550ff and r5, r5, #255 ; 0xff <== NOT EXECUTED
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(b);
if ( sc != RTEMS_SUCCESSFUL)
26204: 1a00000b bne 26238 <fat_buf_access+0x13c> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
26208: e5d43009 ldrb r3, [r4, #9] <== NOT EXECUTED 2620c: e1530005 cmp r3, r5 <== NOT EXECUTED 26210: 9a000012 bls 26260 <fat_buf_access+0x164> <== NOT EXECUTED
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
26214: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
26218: e5942018 ldr r2, [r4, #24] <== NOT EXECUTED
2621c: e2841054 add r1, r4, #84 ; 0x54 <== NOT EXECUTED
26220: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
26224: e0223295 mla r2, r5, r2, r3 <== NOT EXECUTED
26228: e1a0300d mov r3, sp <== NOT EXECUTED
2622c: ebff7cfd bl 5628 <rtems_bdbuf_get> <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
26230: e3500000 cmp r0, #0 <== NOT EXECUTED 26234: 0affffe8 beq 261dc <fat_buf_access+0xe0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
26238: eb00736c bl 42ff0 <__errno> <== NOT EXECUTED 2623c: e3a0300c mov r3, #12 <== NOT EXECUTED 26240: e5803000 str r3, [r0] <== NOT EXECUTED 26244: e3e00000 mvn r0, #0 <== NOT EXECUTED 26248: ea000013 b 2629c <fat_buf_access+0x1a0> <== NOT EXECUTED
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
2624c: e5940084 ldr r0, [r4, #132] ; 0x84 <== NOT EXECUTED 26250: ebff7897 bl 44b4 <rtems_bdbuf_release> <== NOT EXECUTED
fs_info->c.state = FAT_CACHE_EMPTY;
if (sc != RTEMS_SUCCESSFUL)
26254: e3500000 cmp r0, #0 <== NOT EXECUTED
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
fs_info->c.state = FAT_CACHE_EMPTY;
26258: e5c4a081 strb sl, [r4, #129] ; 0x81 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2625c: 1a000027 bne 26300 <fat_buf_access+0x204> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
}
if (op_type == FAT_OP_TYPE_READ)
26260: e3570001 cmp r7, #1 <== NOT EXECUTED 26264: 0a00001f beq 262e8 <fat_buf_access+0x1ec> <== NOT EXECUTED
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
26268: e2841054 add r1, r4, #84 ; 0x54 <== NOT EXECUTED
2626c: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
26270: e1a02006 mov r2, r6 <== NOT EXECUTED
26274: e2843084 add r3, r4, #132 ; 0x84 <== NOT EXECUTED
26278: ebff7cea bl 5628 <rtems_bdbuf_get> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2627c: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
fs_info->c.state = FAT_CACHE_ACTUAL;
26280: 03a03001 moveq r3, #1 <== NOT EXECUTED
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
26284: 0584607c streq r6, [r4, #124] ; 0x7c <== NOT EXECUTED
fs_info->c.state = FAT_CACHE_ACTUAL;
26288: 05c43081 strbeq r3, [r4, #129] ; 0x81 <== NOT EXECUTED
}
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
2628c: 1a00001b bne 26300 <fat_buf_access+0x204> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.blk_num = blk;
fs_info->c.state = FAT_CACHE_ACTUAL;
}
*buf = fs_info->c.buf;
26290: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED 26294: e5883000 str r3, [r8] <== NOT EXECUTED 26298: e3a00000 mov r0, #0 <== NOT EXECUTED
return RC_OK;
}
2629c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
262a0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
fs_info->c.blk_num = blk;
fs_info->c.modified = 0;
fs_info->c.state = FAT_CACHE_ACTUAL;
}
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
262a4: e594501c ldr r5, [r4, #28] <== NOT EXECUTED 262a8: e1550003 cmp r5, r3 <== NOT EXECUTED 262ac: 93a05000 movls r5, #0 <== NOT EXECUTED 262b0: 83a05001 movhi r5, #1 <== NOT EXECUTED 262b4: eaffffac b 2616c <fat_buf_access+0x70> <== NOT EXECUTED
if (fs_info->c.state == FAT_CACHE_EMPTY)
{
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
262b8: e2841054 add r1, r4, #84 ; 0x54 <== NOT EXECUTED
262bc: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
262c0: e1a02006 mov r2, r6 <== NOT EXECUTED
262c4: e2843084 add r3, r4, #132 ; 0x84 <== NOT EXECUTED
262c8: ebff7d0a bl 56f8 <rtems_bdbuf_read> <== NOT EXECUTED
262cc: eaffff9b b 26140 <fat_buf_access+0x44> <== NOT EXECUTED
if (fs_info->c.blk_num != blk)
{
if (fs_info->c.modified)
{
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer,
262d0: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED 262d4: e5940088 ldr r0, [r4, #136] ; 0x88 <== NOT EXECUTED 262d8: e5931020 ldr r1, [r3, #32] <== NOT EXECUTED 262dc: e1d420b0 ldrh r2, [r4] <== NOT EXECUTED 262e0: eb007ff2 bl 462b0 <memcpy> <== NOT EXECUTED 262e4: eaffffaa b 26194 <fat_buf_access+0x98> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
if (op_type == FAT_OP_TYPE_READ)
sc = rtems_bdbuf_read(fs_info->vol.dev, blk, &fs_info->c.buf);
262e8: e2841054 add r1, r4, #84 ; 0x54 <== NOT EXECUTED
262ec: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
262f0: e1a02006 mov r2, r6 <== NOT EXECUTED
262f4: e2843084 add r3, r4, #132 ; 0x84 <== NOT EXECUTED
262f8: ebff7cfe bl 56f8 <rtems_bdbuf_read> <== NOT EXECUTED
262fc: eaffffde b 2627c <fat_buf_access+0x180> <== NOT EXECUTED
else
sc = rtems_bdbuf_get(fs_info->vol.dev, blk, &fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
26300: eb00733a bl 42ff0 <__errno> <== NOT EXECUTED 26304: e3a03005 mov r3, #5 <== NOT EXECUTED 26308: e5803000 str r3, [r0] <== NOT EXECUTED 2630c: e3e00000 mvn r0, #0 <== NOT EXECUTED 26310: eaffffe1 b 2629c <fat_buf_access+0x1a0> <== NOT EXECUTED
00025f90 <fat_buf_release>:
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
25f90: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
25f94: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
25f98: e5d00081 ldrb r0, [r0, #129] ; 0x81 <== NOT EXECUTED 25f9c: e3500000 cmp r0, #0 <== NOT EXECUTED
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
{
25fa0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
uint8_t i;
bool sec_of_fat;
if (fs_info->c.state == FAT_CACHE_EMPTY)
25fa4: 0a000037 beq 26088 <fat_buf_release+0xf8> <== NOT EXECUTED
return RC_OK;
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
25fa8: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED 25fac: e1d421b4 ldrh r2, [r4, #20] <== NOT EXECUTED 25fb0: e1530002 cmp r3, r2 <== NOT EXECUTED 25fb4: 33a05000 movcc r5, #0 <== NOT EXECUTED 25fb8: 2a000034 bcs 26090 <fat_buf_release+0x100> <== NOT EXECUTED
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.modified)
25fbc: e5d43080 ldrb r3, [r4, #128] ; 0x80 <== NOT EXECUTED 25fc0: e3530000 cmp r3, #0 <== NOT EXECUTED 25fc4: 0a000038 beq 260ac <fat_buf_release+0x11c> <== NOT EXECUTED
{
if (sec_of_fat && !fs_info->vol.mirror)
25fc8: e3550000 cmp r5, #0 <== NOT EXECUTED 25fcc: 0a000002 beq 25fdc <fat_buf_release+0x4c> <== NOT EXECUTED 25fd0: e5d43048 ldrb r3, [r4, #72] ; 0x48 <== NOT EXECUTED 25fd4: e3530000 cmp r3, #0 <== NOT EXECUTED 25fd8: 0a00003a beq 260c8 <fat_buf_release+0x138> <== NOT EXECUTED
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
25fdc: e5940084 ldr r0, [r4, #132] ; 0x84 <== NOT EXECUTED 25fe0: ebff7911 bl 442c <rtems_bdbuf_release_modified> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
25fe4: e3500000 cmp r0, #0 <== NOT EXECUTED 25fe8: 1a00003c bne 260e0 <fat_buf_release+0x150> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
if (sec_of_fat && !fs_info->vol.mirror)
25fec: e3550000 cmp r5, #0 <== NOT EXECUTED
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
fs_info->c.modified = 0;
25ff0: e5c40080 strb r0, [r4, #128] ; 0x80 <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
25ff4: 0a000030 beq 260bc <fat_buf_release+0x12c> <== NOT EXECUTED 25ff8: e5d43048 ldrb r3, [r4, #72] ; 0x48 <== NOT EXECUTED 25ffc: e3530000 cmp r3, #0 <== NOT EXECUTED 26000: 1a00002d bne 260bc <fat_buf_release+0x12c> <== NOT EXECUTED
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
26004: e5d43009 ldrb r3, [r4, #9] <== NOT EXECUTED 26008: e3530001 cmp r3, #1 <== NOT EXECUTED 2600c: 9a00002a bls 260bc <fat_buf_release+0x12c> <== NOT EXECUTED 26010: e3a05001 mov r5, #1 <== NOT EXECUTED 26014: e1a0600d mov r6, sp <== NOT EXECUTED 26018: ea00000d b 26054 <fat_buf_release+0xc4> <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
2601c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 26020: e5941088 ldr r1, [r4, #136] ; 0x88 <== NOT EXECUTED 26024: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 26028: e1d420b0 ldrh r2, [r4] <== NOT EXECUTED 2602c: eb00809f bl 462b0 <memcpy> <== NOT EXECUTED
sc = rtems_bdbuf_release_modified(b);
26030: e59d0000 ldr r0, [sp] <== NOT EXECUTED 26034: ebff78fc bl 442c <rtems_bdbuf_release_modified> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
26038: e2855001 add r5, r5, #1 <== NOT EXECUTED
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(b);
if ( sc != RTEMS_SUCCESSFUL)
2603c: e3500000 cmp r0, #0 <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
26040: e20550ff and r5, r5, #255 ; 0xff <== NOT EXECUTED
&b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(b);
if ( sc != RTEMS_SUCCESSFUL)
26044: 1a00000b bne 26078 <fat_buf_release+0xe8> <== NOT EXECUTED
if (sec_of_fat && !fs_info->vol.mirror)
{
rtems_bdbuf_buffer *b;
for (i = 1; i < fs_info->vol.fats; i++)
26048: e5d43009 ldrb r3, [r4, #9] <== NOT EXECUTED 2604c: e1530005 cmp r3, r5 <== NOT EXECUTED 26050: 9a000019 bls 260bc <fat_buf_release+0x12c> <== NOT EXECUTED
{
sc = rtems_bdbuf_get(fs_info->vol.dev,
26054: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
26058: e5942018 ldr r2, [r4, #24] <== NOT EXECUTED
2605c: e2841054 add r1, r4, #84 ; 0x54 <== NOT EXECUTED
26060: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
26064: e0223295 mla r2, r5, r2, r3 <== NOT EXECUTED
26068: e1a0300d mov r3, sp <== NOT EXECUTED
2606c: ebff7d6d bl 5628 <rtems_bdbuf_get> <== NOT EXECUTED
fs_info->c.blk_num +
fs_info->vol.fat_length * i,
&b);
if ( sc != RTEMS_SUCCESSFUL)
26070: e3500000 cmp r0, #0 <== NOT EXECUTED 26074: 0affffe8 beq 2601c <fat_buf_release+0x8c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
memcpy(b->buffer, fs_info->sec_buf, fs_info->vol.bps);
sc = rtems_bdbuf_release_modified(b);
if ( sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(ENOMEM);
26078: eb0073dc bl 42ff0 <__errno> <== NOT EXECUTED 2607c: e3a0300c mov r3, #12 <== NOT EXECUTED 26080: e5803000 str r3, [r0] <== NOT EXECUTED 26084: e3e00000 mvn r0, #0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
return RC_OK;
}
26088: e28dd004 add sp, sp, #4 <== NOT EXECUTED
2608c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
*buf = fs_info->c.buf;
return RC_OK;
}
int
fat_buf_release(fat_fs_info_t *fs_info)
26090: e594501c ldr r5, [r4, #28] <== NOT EXECUTED 26094: e1530005 cmp r3, r5 <== NOT EXECUTED 26098: 23a05000 movcs r5, #0 <== NOT EXECUTED 2609c: 33a05001 movcc r5, #1 <== NOT EXECUTED
return RC_OK;
sec_of_fat = ((fs_info->c.blk_num >= fs_info->vol.fat_loc) &&
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.modified)
260a0: e5d43080 ldrb r3, [r4, #128] ; 0x80 <== NOT EXECUTED 260a4: e3530000 cmp r3, #0 <== NOT EXECUTED 260a8: 1affffc6 bne 25fc8 <fat_buf_release+0x38> <== NOT EXECUTED
}
}
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
260ac: e5940084 ldr r0, [r4, #132] ; 0x84 <== NOT EXECUTED 260b0: ebff78ff bl 44b4 <rtems_bdbuf_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
260b4: e3500000 cmp r0, #0 <== NOT EXECUTED 260b8: 1a000008 bne 260e0 <fat_buf_release+0x150> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
}
fs_info->c.state = FAT_CACHE_EMPTY;
260bc: e3a00000 mov r0, #0 <== NOT EXECUTED 260c0: e5c40081 strb r0, [r4, #129] ; 0x81 <== NOT EXECUTED
return RC_OK;
260c4: eaffffef b 26088 <fat_buf_release+0xf8> <== NOT EXECUTED
(fs_info->c.blk_num < fs_info->vol.rdir_loc));
if (fs_info->c.modified)
{
if (sec_of_fat && !fs_info->vol.mirror)
memcpy(fs_info->sec_buf, fs_info->c.buf->buffer, fs_info->vol.bps);
260c8: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED 260cc: e5940088 ldr r0, [r4, #136] ; 0x88 <== NOT EXECUTED 260d0: e5931020 ldr r1, [r3, #32] <== NOT EXECUTED 260d4: e1d420b0 ldrh r2, [r4] <== NOT EXECUTED 260d8: eb008074 bl 462b0 <memcpy> <== NOT EXECUTED 260dc: eaffffbe b 25fdc <fat_buf_release+0x4c> <== NOT EXECUTED
}
else
{
sc = rtems_bdbuf_release(fs_info->c.buf);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
260e0: eb0073c2 bl 42ff0 <__errno> <== NOT EXECUTED 260e4: e3a03005 mov r3, #5 <== NOT EXECUTED 260e8: e5803000 str r3, [r0] <== NOT EXECUTED 260ec: e3e00000 mvn r0, #0 <== NOT EXECUTED 260f0: eaffffe4 b 26088 <fat_buf_release+0xf8> <== NOT EXECUTED
00026d70 <fat_cluster_read>:
fat_cluster_read(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
void *buff
)
{
26d70: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
26d74: e2513000 subs r3, r1, #0 <== NOT EXECUTED 26d78: e1a0c002 mov ip, r2 <== NOT EXECUTED 26d7c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
26d80: e5902034 ldr r2, [r0, #52] ; 0x34 <== NOT EXECUTED 26d84: 1a000003 bne 26d98 <fat_cluster_read+0x28> <== NOT EXECUTED 26d88: e5d2100a ldrb r1, [r2, #10] <== NOT EXECUTED 26d8c: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
26d90: 1592101c ldrne r1, [r2, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
26d94: 1a000003 bne 26da8 <fat_cluster_read+0x38> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
26d98: e5d21005 ldrb r1, [r2, #5] <== NOT EXECUTED 26d9c: e592e030 ldr lr, [r2, #48] ; 0x30 <== NOT EXECUTED 26da0: e2433002 sub r3, r3, #2 <== NOT EXECUTED 26da4: e08e1113 add r1, lr, r3, lsl r1 <== NOT EXECUTED
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_read(mt_entry, fsec, 0,
26da8: e5d23002 ldrb r3, [r2, #2] <== NOT EXECUTED 26dac: e5d22004 ldrb r2, [r2, #4] <== NOT EXECUTED 26db0: e1a03312 lsl r3, r2, r3 <== NOT EXECUTED 26db4: e3a02000 mov r2, #0 <== NOT EXECUTED 26db8: e58dc000 str ip, [sp] <== NOT EXECUTED 26dbc: ebfffe21 bl 26648 <_fat_block_read> <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
}
26dc0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
26dc4: e8bd8000 pop {pc} <== NOT EXECUTED
00026540 <fat_cluster_write>:
fat_cluster_write(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
const void *buff
)
{
26540: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
26544: e2513000 subs r3, r1, #0 <== NOT EXECUTED 26548: e1a0c002 mov ip, r2 <== NOT EXECUTED 2654c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
26550: e5902034 ldr r2, [r0, #52] ; 0x34 <== NOT EXECUTED 26554: 1a000003 bne 26568 <fat_cluster_write+0x28> <== NOT EXECUTED 26558: e5d2100a ldrb r1, [r2, #10] <== NOT EXECUTED 2655c: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
26560: 1592101c ldrne r1, [r2, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
26564: 1a000003 bne 26578 <fat_cluster_write+0x38> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
26568: e5d21005 ldrb r1, [r2, #5] <== NOT EXECUTED 2656c: e592e030 ldr lr, [r2, #48] ; 0x30 <== NOT EXECUTED 26570: e2433002 sub r3, r3, #2 <== NOT EXECUTED 26574: e08e1113 add r1, lr, r3, lsl r1 <== NOT EXECUTED
uint32_t fsec = 0;
fsec = fat_cluster_num_to_sector_num(mt_entry, cln);
return _fat_block_write(mt_entry, fsec, 0,
26578: e5d23002 ldrb r3, [r2, #2] <== NOT EXECUTED 2657c: e5d22004 ldrb r2, [r2, #4] <== NOT EXECUTED 26580: e1a03312 lsl r3, r2, r3 <== NOT EXECUTED 26584: e3a02000 mov r2, #0 <== NOT EXECUTED 26588: e58dc000 str ip, [sp] <== NOT EXECUTED 2658c: ebffff60 bl 26314 <_fat_block_write> <== NOT EXECUTED
fs_info->vol.spc << fs_info->vol.sec_log2, buff);
}
26590: e28dd004 add sp, sp, #4 <== NOT EXECUTED
26594: e8bd8000 pop {pc} <== NOT EXECUTED
000263f0 <fat_fat32_update_fsinfo_sector>:
fat_fat32_update_fsinfo_sector(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t free_count,
uint32_t next_free
)
{
263f0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
ssize_t ret1 = 0, ret2 = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
263f4: e5905034 ldr r5, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
le_next_free = CT_LE_L(next_free);
ret1 = _fat_block_write(mt_entry,
263f8: e1d533bc ldrh r3, [r5, #60] ; 0x3c <== NOT EXECUTED
fat_fat32_update_fsinfo_sector(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t free_count,
uint32_t next_free
)
{
263fc: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
le_next_free = CT_LE_L(next_free);
ret1 = _fat_block_write(mt_entry,
26400: e28dc008 add ip, sp, #8 <== NOT EXECUTED
ssize_t ret1 = 0, ret2 = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t le_free_count = 0;
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
26404: e58d1008 str r1, [sp, #8] <== NOT EXECUTED
le_next_free = CT_LE_L(next_free);
26408: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
ret1 = _fat_block_write(mt_entry,
2640c: e1a01003 mov r1, r3 <== NOT EXECUTED 26410: e3a02f7a mov r2, #488 ; 0x1e8 <== NOT EXECUTED 26414: e3a03004 mov r3, #4 <== NOT EXECUTED
fat_fat32_update_fsinfo_sector(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t free_count,
uint32_t next_free
)
{
26418: e1a04000 mov r4, r0 <== NOT EXECUTED
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
le_next_free = CT_LE_L(next_free);
ret1 = _fat_block_write(mt_entry,
2641c: e58dc000 str ip, [sp] <== NOT EXECUTED 26420: ebffffbb bl 26314 <_fat_block_write> <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
4,
(char *)(&le_free_count));
ret2 = _fat_block_write(mt_entry,
26424: e3a03004 mov r3, #4 <== NOT EXECUTED 26428: e1d513bc ldrh r1, [r5, #60] ; 0x3c <== NOT EXECUTED 2642c: e08dc003 add ip, sp, r3 <== NOT EXECUTED
uint32_t le_next_free = 0;
le_free_count = CT_LE_L(free_count);
le_next_free = CT_LE_L(next_free);
ret1 = _fat_block_write(mt_entry,
26430: e1a06000 mov r6, r0 <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_FREE_CLUSTER_COUNT_OFFSET,
4,
(char *)(&le_free_count));
ret2 = _fat_block_write(mt_entry,
26434: e3a02f7b mov r2, #492 ; 0x1ec <== NOT EXECUTED 26438: e1a00004 mov r0, r4 <== NOT EXECUTED 2643c: e58dc000 str ip, [sp] <== NOT EXECUTED 26440: ebffffb3 bl 26314 <_fat_block_write> <== NOT EXECUTED
fs_info->vol.info_sec,
FAT_FSINFO_NEXT_FREE_CLUSTER_OFFSET,
4,
(char *)(&le_next_free));
if ( (ret1 < 0) || (ret2 < 0) )
26444: e1a06fa6 lsr r6, r6, #31 <== NOT EXECUTED 26448: e1960fa0 orrs r0, r6, r0, lsr #31 <== NOT EXECUTED
return -1;
return RC_OK;
}
2644c: 13e00000 mvnne r0, #0 <== NOT EXECUTED
26450: e28dd00c add sp, sp, #12 <== NOT EXECUTED
26454: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00025b58 <fat_file_close>:
/*
* if links_num field of fat-file descriptor is greater than 1
* decrement the count of links and return
*/
if (fat_fd->links_num > 1)
25b58: e5913008 ldr r3, [r1, #8] <== NOT EXECUTED 25b5c: e3530001 cmp r3, #1 <== NOT EXECUTED
{
fat_fd->links_num--;
25b60: 82433001 subhi r3, r3, #1 <== NOT EXECUTED
int
fat_file_close(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
25b64: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
* if links_num field of fat-file descriptor is greater than 1
* decrement the count of links and return
*/
if (fat_fd->links_num > 1)
{
fat_fd->links_num--;
25b68: 85813008 strhi r3, [r1, #8] <== NOT EXECUTED
int
fat_file_close(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
25b6c: e1a05000 mov r5, r0 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
25b70: e5906034 ldr r6, [r0, #52] ; 0x34 <== NOT EXECUTED
int
fat_file_close(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
25b74: e1a04001 mov r4, r1 <== NOT EXECUTED
* if links_num field of fat-file descriptor is greater than 1
* decrement the count of links and return
*/
if (fat_fd->links_num > 1)
{
fat_fd->links_num--;
25b78: 83a00000 movhi r0, #0 <== NOT EXECUTED
/*
* if links_num field of fat-file descriptor is greater than 1
* decrement the count of links and return
*/
if (fat_fd->links_num > 1)
25b7c: 88bd80f0 pophi {r4, r5, r6, r7, pc} <== NOT EXECUTED
return rc;
}
key = fat_construct_key(mt_entry, &fat_fd->dir_pos.sname);
if (fat_fd->flags & FAT_FILE_REMOVED)
25b80: e5d17030 ldrb r7, [r1, #48] ; 0x30 <== NOT EXECUTED 25b84: e2177001 ands r7, r7, #1 <== NOT EXECUTED 25b88: 0a00000d beq 25bc4 <fat_file_close+0x6c> <== NOT EXECUTED
{
rc = fat_file_truncate(mt_entry, fat_fd, 0);
25b8c: e3a02000 mov r2, #0 <== NOT EXECUTED 25b90: ebfffe1d bl 2540c <fat_file_truncate> <== NOT EXECUTED
if ( rc != RC_OK )
25b94: e3500000 cmp r0, #0 <== NOT EXECUTED
25b98: 18bd80f0 popne {r4, r5, r6, r7, pc} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
25b9c: e1a00004 mov r0, r4 <== NOT EXECUTED 25ba0: ebff9d42 bl d0b0 <_Chain_Extract> <== NOT EXECUTED
return rc;
_hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
if ( fat_ino_is_unique(mt_entry, fat_fd->ino) )
25ba4: e1a00005 mov r0, r5 <== NOT EXECUTED 25ba8: e594100c ldr r1, [r4, #12] <== NOT EXECUTED 25bac: eb0000b6 bl 25e8c <fat_ino_is_unique> <== NOT EXECUTED 25bb0: e3500000 cmp r0, #0 <== NOT EXECUTED 25bb4: 1a00000d bne 25bf0 <fat_file_close+0x98> <== NOT EXECUTED
fat_fd->links_num = 0;
}
else
{
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
free(fat_fd);
25bb8: e1a00004 mov r0, r4 <== NOT EXECUTED 25bbc: ebff886b bl 7d70 <free> <== NOT EXECUTED 25bc0: ea000004 b 25bd8 <fat_file_close+0x80> <== NOT EXECUTED
free(fat_fd);
}
else
{
if (fat_ino_is_unique(mt_entry, fat_fd->ino))
25bc4: e591100c ldr r1, [r1, #12] <== NOT EXECUTED 25bc8: eb0000af bl 25e8c <fat_ino_is_unique> <== NOT EXECUTED 25bcc: e3500000 cmp r0, #0 <== NOT EXECUTED
{
fat_fd->links_num = 0;
25bd0: 15847008 strne r7, [r4, #8] <== NOT EXECUTED
free(fat_fd);
}
else
{
if (fat_ino_is_unique(mt_entry, fat_fd->ino))
25bd4: 0a000002 beq 25be4 <fat_file_close+0x8c> <== NOT EXECUTED
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
25bd8: e1a00006 mov r0, r6 <== NOT EXECUTED
return rc;
}
25bdc: e8bd40f0 pop {r4, r5, r6, r7, lr} <== NOT EXECUTED
}
}
/*
* flush any modified "cached" buffer back to disk
*/
rc = fat_buf_release(fs_info);
25be0: ea0000ea b 25f90 <fat_buf_release> <== NOT EXECUTED 25be4: e1a00004 mov r0, r4 <== NOT EXECUTED 25be8: ebff9d30 bl d0b0 <_Chain_Extract> <== NOT EXECUTED 25bec: eafffff1 b 25bb8 <fat_file_close+0x60> <== NOT EXECUTED
return rc;
_hash_delete(fs_info->rhash, key, fat_fd->ino, fat_fd);
if ( fat_ino_is_unique(mt_entry, fat_fd->ino) )
fat_free_unique_ino(mt_entry, fat_fd->ino);
25bf0: e1a00005 mov r0, r5 <== NOT EXECUTED 25bf4: e594100c ldr r1, [r4, #12] <== NOT EXECUTED 25bf8: eb000099 bl 25e64 <fat_free_unique_ino> <== NOT EXECUTED 25bfc: eaffffed b 25bb8 <fat_file_close+0x60> <== NOT EXECUTED
000251b4 <fat_file_datasync>:
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
251b4: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
uint32_t cur_cln = fat_fd->cln;
rtems_bdbuf_buffer *block = NULL;
uint32_t sec = 0;
uint32_t i = 0;
if (fat_fd->fat_file_size == 0)
251b8: e5913018 ldr r3, [r1, #24] <== NOT EXECUTED 251bc: e3530000 cmp r3, #0 <== NOT EXECUTED
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
251c0: e1a08000 mov r8, r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
251c4: e5905034 ldr r5, [r0, #52] ; 0x34 <== NOT EXECUTED
int
fat_file_datasync(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
251c8: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
251cc: e591201c ldr r2, [r1, #28] <== NOT EXECUTED
rtems_bdbuf_buffer *block = NULL;
uint32_t sec = 0;
uint32_t i = 0;
if (fat_fd->fat_file_size == 0)
251d0: 01a00003 moveq r0, r3 <== NOT EXECUTED 251d4: 1a000001 bne 251e0 <fat_file_datasync+0x2c> <== NOT EXECUTED
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
}
return rc;
}
251d8: e28dd008 add sp, sp, #8 <== NOT EXECUTED
251dc: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
rtems_bdbuf_buffer *block = NULL;
251e0: e3a03000 mov r3, #0 <== NOT EXECUTED
/*
* we can use only one bdbuf :( and we also know that cache is useless
* for sync operation, so don't use it
*/
rc = fat_buf_release(fs_info);
251e4: e1a00005 mov r0, r5 <== NOT EXECUTED
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
rtems_bdbuf_buffer *block = NULL;
251e8: e58d3000 str r3, [sp] <== NOT EXECUTED
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
251ec: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
/*
* we can use only one bdbuf :( and we also know that cache is useless
* for sync operation, so don't use it
*/
rc = fat_buf_release(fs_info);
251f0: eb000366 bl 25f90 <fat_buf_release> <== NOT EXECUTED
if (rc != RC_OK)
251f4: e250a000 subs sl, r0, #0 <== NOT EXECUTED 251f8: 01a0700d moveq r7, sp <== NOT EXECUTED
sc = rtems_bdbuf_sync(block);
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
251fc: 028d9004 addeq r9, sp, #4 <== NOT EXECUTED
/*
* we can use only one bdbuf :( and we also know that cache is useless
* for sync operation, so don't use it
*/
rc = fat_buf_release(fs_info);
if (rc != RC_OK)
25200: 1a00002a bne 252b0 <fat_file_datasync+0xfc> <== NOT EXECUTED
return rc;
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
25204: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
25208: e285200c add r2, r5, #12 <== NOT EXECUTED
2520c: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
25210: e0012002 and r2, r1, r2 <== NOT EXECUTED
25214: e1520003 cmp r2, r3 <== NOT EXECUTED
25218: 2a000024 bcs 252b0 <fat_file_datasync+0xfc> <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2521c: e3510000 cmp r1, #0 <== NOT EXECUTED
fat_cluster_num_to_sector_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
25220: e5983034 ldr r3, [r8, #52] ; 0x34 <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25224: 0a00001c beq 2529c <fat_file_datasync+0xe8> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
25228: e5932030 ldr r2, [r3, #48] ; 0x30 <== NOT EXECUTED 2522c: e5d33005 ldrb r3, [r3, #5] <== NOT EXECUTED 25230: e2416002 sub r6, r1, #2 <== NOT EXECUTED 25234: e0826316 add r6, r2, r6, lsl r3 <== NOT EXECUTED
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
25238: e5d53004 ldrb r3, [r5, #4] <== NOT EXECUTED 2523c: e3530000 cmp r3, #0 <== NOT EXECUTED 25240: 0a00001d beq 252bc <fat_file_datasync+0x108> <== NOT EXECUTED 25244: e3a04000 mov r4, #0 <== NOT EXECUTED 25248: ea000006 b 25268 <fat_file_datasync+0xb4> <== NOT EXECUTED
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one( EIO );
sc = rtems_bdbuf_sync(block);
2524c: e59d0000 ldr r0, [sp] <== NOT EXECUTED 25250: ebff7f0d bl 4e8c <rtems_bdbuf_sync> <== NOT EXECUTED
if ( sc != RTEMS_SUCCESSFUL )
25254: e3500000 cmp r0, #0 <== NOT EXECUTED 25258: 1a00000a bne 25288 <fat_file_datasync+0xd4> <== NOT EXECUTED
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
2525c: e5d53004 ldrb r3, [r5, #4] <== NOT EXECUTED 25260: e1530004 cmp r3, r4 <== NOT EXECUTED 25264: 9a000013 bls 252b8 <fat_file_datasync+0x104> <== NOT EXECUTED
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
25268: e0842006 add r2, r4, r6 <== NOT EXECUTED
2526c: e2851054 add r1, r5, #84 ; 0x54 <== NOT EXECUTED
25270: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
25274: e1a0300d mov r3, sp <== NOT EXECUTED
25278: ebff811e bl 56f8 <rtems_bdbuf_read> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2527c: e3500000 cmp r0, #0 <== NOT EXECUTED
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
25280: e2844001 add r4, r4, #1 <== NOT EXECUTED
{
/* ... sync it */
sc = rtems_bdbuf_read(fs_info->vol.dev, (sec + i), &block);
if (sc != RTEMS_SUCCESSFUL)
25284: 0afffff0 beq 2524c <fat_file_datasync+0x98> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
sc = rtems_bdbuf_sync(block);
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
25288: eb007758 bl 42ff0 <__errno> <== NOT EXECUTED 2528c: e3a03005 mov r3, #5 <== NOT EXECUTED 25290: e5803000 str r3, [r0] <== NOT EXECUTED 25294: e3e00000 mvn r0, #0 <== NOT EXECUTED 25298: eaffffce b 251d8 <fat_file_datasync+0x24> <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
2529c: e5d3200a ldrb r2, [r3, #10] <== NOT EXECUTED 252a0: e3120003 tst r2, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
252a4: 1593601c ldrne r6, [r3, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
252a8: 1affffe2 bne 25238 <fat_file_datasync+0x84> <== NOT EXECUTED 252ac: eaffffdd b 25228 <fat_file_datasync+0x74> <== NOT EXECUTED
rc = fat_buf_release(fs_info);
if (rc != RC_OK)
return rc;
/* for each cluster of the file ... */
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
252b0: e1a0000a mov r0, sl <== NOT EXECUTED 252b4: eaffffc7 b 251d8 <fat_file_datasync+0x24> <== NOT EXECUTED
{
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
/* for each sector in cluster ... */
for ( i = 0; i < fs_info->vol.spc; i++ )
252b8: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
sc = rtems_bdbuf_sync(block);
if ( sc != RTEMS_SUCCESSFUL )
rtems_set_errno_and_return_minus_one( EIO );
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
252bc: e1a00008 mov r0, r8 <== NOT EXECUTED 252c0: e1a02009 mov r2, r9 <== NOT EXECUTED 252c4: eb0066d7 bl 3ee28 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
252c8: e3500000 cmp r0, #0 <== NOT EXECUTED 252cc: 0affffcc beq 25204 <fat_file_datasync+0x50> <== NOT EXECUTED 252d0: eaffffc0 b 251d8 <fat_file_datasync+0x24> <== NOT EXECUTED
00025514 <fat_file_extend>:
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
25514: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
25518: e1a08003 mov r8, r3 <== NOT EXECUTED
uint32_t old_last_cl;
uint32_t last_cl = 0;
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
2551c: e5882000 str r2, [r8] <== NOT EXECUTED
if (new_length <= fat_fd->fat_file_size)
25520: e591b018 ldr fp, [r1, #24] <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
25524: e24dd014 sub sp, sp, #20 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t chain = 0;
25528: e3a03000 mov r3, #0 <== NOT EXECUTED
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
2552c: e152000b cmp r2, fp <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length,
uint32_t *a_length
)
{
25530: e1a04002 mov r4, r2 <== NOT EXECUTED 25534: e1a05001 mov r5, r1 <== NOT EXECUTED 25538: e1a06000 mov r6, r0 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t chain = 0;
uint32_t bytes2add = 0;
uint32_t cls2add = 0;
uint32_t old_last_cl;
uint32_t last_cl = 0;
2553c: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
uint32_t *a_length
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t chain = 0;
25540: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
uint32_t new_length,
uint32_t *a_length
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
25544: e5907034 ldr r7, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t bytes_remain = 0;
uint32_t cls_added;
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
25548: 9a000039 bls 25634 <fat_file_extend+0x120> <== NOT EXECUTED
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2554c: e5913020 ldr r3, [r1, #32] <== NOT EXECUTED 25550: e3530001 cmp r3, #1 <== NOT EXECUTED 25554: 0a00003a beq 25644 <fat_file_extend+0x130> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
25558: e1d720b6 ldrh r2, [r7, #6] <== NOT EXECUTED
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
2555c: e2423001 sub r3, r2, #1 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
rtems_set_errno_and_return_minus_one( ENOSPC );
bytes_remain = (fs_info->vol.bpc -
25560: e003a00b and sl, r3, fp <== NOT EXECUTED 25564: e06aa002 rsb sl, sl, r2 <== NOT EXECUTED 25568: e00aa003 and sl, sl, r3 <== NOT EXECUTED
(fat_fd->fat_file_size & (fs_info->vol.bpc - 1))) &
(fs_info->vol.bpc - 1);
bytes2add = new_length - fat_fd->fat_file_size;
2556c: e06bb004 rsb fp, fp, r4 <== NOT EXECUTED
if (bytes2add > bytes_remain)
25570: e15a000b cmp sl, fp <== NOT EXECUTED 25574: 2a00002e bcs 25634 <fat_file_extend+0x120> <== NOT EXECUTED
/*
* if in last cluster allocated for the file there is enough room to
* handle extention (hence we don't need to add even one cluster to the
* file ) - return
*/
if (bytes2add == 0)
25578: e05bb00a subs fp, fp, sl <== NOT EXECUTED 2557c: 0a00002c beq 25634 <fat_file_extend+0x120> <== NOT EXECUTED
return RC_OK;
cls2add = ((bytes2add - 1) >> fs_info->vol.bpc_log2) + 1;
25580: e5d73008 ldrb r3, [r7, #8] <== NOT EXECUTED 25584: e24b9001 sub r9, fp, #1 <== NOT EXECUTED 25588: e1a09339 lsr r9, r9, r3 <== NOT EXECUTED 2558c: e2899001 add r9, r9, #1 <== NOT EXECUTED
rc = fat_scan_fat_for_free_clusters(mt_entry, &chain, cls2add,
25590: e28dc008 add ip, sp, #8 <== NOT EXECUTED 25594: e1a00006 mov r0, r6 <== NOT EXECUTED 25598: e28d1010 add r1, sp, #16 <== NOT EXECUTED 2559c: e1a02009 mov r2, r9 <== NOT EXECUTED 255a0: e28d3004 add r3, sp, #4 <== NOT EXECUTED 255a4: e58dc000 str ip, [sp] <== NOT EXECUTED 255a8: eb0066b5 bl 3f084 <fat_scan_fat_for_free_clusters> <== NOT EXECUTED
&cls_added, &last_cl);
/* this means that low level I/O error occured */
if (rc != RC_OK)
255ac: e3500000 cmp r0, #0 <== NOT EXECUTED 255b0: 11a08000 movne r8, r0 <== NOT EXECUTED 255b4: 1a00001f bne 25638 <fat_file_extend+0x124> <== NOT EXECUTED
return rc;
/* this means that no space left on device */
if ((cls_added == 0) && (bytes_remain == 0))
255b8: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 255bc: e19aa002 orrs sl, sl, r2 <== NOT EXECUTED 255c0: 0a000025 beq 2565c <fat_file_extend+0x148> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOSPC);
/* check wether we satisfied request for 'cls2add' clusters */
if (cls2add != cls_added)
255c4: e1590002 cmp r9, r2 <== NOT EXECUTED 255c8: 0a000008 beq 255f0 <fat_file_extend+0xdc> <== NOT EXECUTED
*a_length = new_length -
255cc: e5d73008 ldrb r3, [r7, #8] <== NOT EXECUTED 255d0: e1e01002 mvn r1, r2 <== NOT EXECUTED 255d4: e0819009 add r9, r1, r9 <== NOT EXECUTED 255d8: e0449319 sub r9, r4, r9, lsl r3 <== NOT EXECUTED 255dc: e1d730b6 ldrh r3, [r7, #6] <== NOT EXECUTED 255e0: e2433001 sub r3, r3, #1 <== NOT EXECUTED 255e4: e00bb003 and fp, fp, r3 <== NOT EXECUTED 255e8: e06bb009 rsb fp, fp, r9 <== NOT EXECUTED 255ec: e588b000 str fp, [r8] <== NOT EXECUTED
((cls2add - cls_added - 1) << fs_info->vol.bpc_log2) -
(bytes2add & (fs_info->vol.bpc - 1));
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
255f0: e5953018 ldr r3, [r5, #24] <== NOT EXECUTED 255f4: e3530000 cmp r3, #0 <== NOT EXECUTED 255f8: 1a00001c bne 25670 <fat_file_extend+0x15c> <== NOT EXECUTED
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
255fc: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
fat_fd->map.file_cln = 0;
25600: e5853034 str r3, [r5, #52] ; 0x34 <== NOT EXECUTED
(bytes2add & (fs_info->vol.bpc - 1));
/* add new chain to the end of existed */
if ( fat_fd->fat_file_size == 0 )
{
fat_fd->map.disk_cln = fat_fd->cln = chain;
25604: e5851038 str r1, [r5, #56] ; 0x38 <== NOT EXECUTED 25608: e585101c str r1, [r5, #28] <== NOT EXECUTED
}
fat_buf_release(fs_info);
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
2560c: e3520000 cmp r2, #0 <== NOT EXECUTED 25610: 0a000004 beq 25628 <fat_file_extend+0x114> <== NOT EXECUTED
{
fat_fd->map.last_cln = last_cl;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
25614: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED 25618: e3530001 cmp r3, #1 <== NOT EXECUTED
}
/* update number of the last cluster of the file if it changed */
if (cls_added != 0)
{
fat_fd->map.last_cln = last_cl;
2561c: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 25620: e585303c str r3, [r5, #60] ; 0x3c <== NOT EXECUTED
if (fat_fd->fat_file_type == FAT_DIRECTORY)
25624: 0a00001e beq 256a4 <fat_file_extend+0x190> <== NOT EXECUTED
return rc;
}
}
}
fat_fd->fat_file_size = new_length;
25628: e5854018 str r4, [r5, #24] <== NOT EXECUTED 2562c: e3a08000 mov r8, #0 <== NOT EXECUTED
return RC_OK;
25630: ea000000 b 25638 <fat_file_extend+0x124> <== NOT EXECUTED 25634: e3a08000 mov r8, #0 <== NOT EXECUTED
}
25638: e1a00008 mov r0, r8 <== NOT EXECUTED
2563c: e28dd014 add sp, sp, #20 <== NOT EXECUTED
25640: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
*a_length = new_length;
if (new_length <= fat_fd->fat_file_size)
return RC_OK;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
25644: e5913024 ldr r3, [r1, #36] ; 0x24 <== NOT EXECUTED 25648: e3530000 cmp r3, #0 <== NOT EXECUTED 2564c: 1affffc1 bne 25558 <fat_file_extend+0x44> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
25650: e5d7300a ldrb r3, [r7, #10] <== NOT EXECUTED 25654: e3130003 tst r3, #3 <== NOT EXECUTED 25658: 0affffbe beq 25558 <fat_file_extend+0x44> <== NOT EXECUTED
if (rc != RC_OK)
return rc;
/* this means that no space left on device */
if ((cls_added == 0) && (bytes_remain == 0))
rtems_set_errno_and_return_minus_one(ENOSPC);
2565c: eb007663 bl 42ff0 <__errno> <== NOT EXECUTED 25660: e3a0301c mov r3, #28 <== NOT EXECUTED 25664: e5803000 str r3, [r0] <== NOT EXECUTED 25668: e3e08000 mvn r8, #0 <== NOT EXECUTED 2566c: eafffff1 b 25638 <fat_file_extend+0x124> <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln = chain;
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
25670: e595103c ldr r1, [r5, #60] ; 0x3c <== NOT EXECUTED 25674: e3710001 cmn r1, #1 <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
25678: 158d100c strne r1, [sp, #12] <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln = chain;
fat_fd->map.file_cln = 0;
}
else
{
if (fat_fd->map.last_cln != FAT_UNDEFINED_VALUE)
2567c: 0a000011 beq 256c8 <fat_file_extend+0x1b4> <== NOT EXECUTED
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
}
}
rc = fat_set_fat_cluster(mt_entry, old_last_cl, chain);
25680: e1a00006 mov r0, r6 <== NOT EXECUTED 25684: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 25688: eb006545 bl 3eba4 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
2568c: e2508000 subs r8, r0, #0 <== NOT EXECUTED 25690: 1a000008 bne 256b8 <fat_file_extend+0x1a4> <== NOT EXECUTED
{
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
}
fat_buf_release(fs_info);
25694: e1a00007 mov r0, r7 <== NOT EXECUTED 25698: eb00023c bl 25f90 <fat_buf_release> <== NOT EXECUTED 2569c: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 256a0: eaffffd9 b 2560c <fat_file_extend+0xf8> <== NOT EXECUTED
if (cls_added != 0)
{
fat_fd->map.last_cln = last_cl;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
{
rc = fat_init_clusters_chain(mt_entry, chain);
256a4: e1a00006 mov r0, r6 <== NOT EXECUTED 256a8: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 256ac: eb0003b9 bl 26598 <fat_init_clusters_chain> <== NOT EXECUTED
if ( rc != RC_OK )
256b0: e2508000 subs r8, r0, #0 <== NOT EXECUTED 256b4: 0affffdb beq 25628 <fat_file_extend+0x114> <== NOT EXECUTED
{
fat_free_fat_clusters_chain(mt_entry, chain);
256b8: e1a00006 mov r0, r6 <== NOT EXECUTED 256bc: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 256c0: eb006639 bl 3efac <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
256c4: eaffffdb b 25638 <fat_file_extend+0x124> <== NOT EXECUTED
{
old_last_cl = fat_fd->map.last_cln;
}
else
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
256c8: e1a01005 mov r1, r5 <== NOT EXECUTED 256cc: e28dc00c add ip, sp, #12 <== NOT EXECUTED 256d0: e2433001 sub r3, r3, #1 <== NOT EXECUTED 256d4: e1a00006 mov r0, r6 <== NOT EXECUTED 256d8: e3a02001 mov r2, #1 <== NOT EXECUTED 256dc: e58dc000 str ip, [sp] <== NOT EXECUTED 256e0: ebffff0f bl 25324 <fat_file_ioctl> <== NOT EXECUTED
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
256e4: e2508000 subs r8, r0, #0 <== NOT EXECUTED
{
fat_free_fat_clusters_chain(mt_entry, chain);
return rc;
256e8: 059d100c ldreq r1, [sp, #12] <== NOT EXECUTED
}
else
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
(fat_fd->fat_file_size - 1), &old_last_cl);
if ( rc != RC_OK )
256ec: 0affffe3 beq 25680 <fat_file_extend+0x16c> <== NOT EXECUTED 256f0: eafffff0 b 256b8 <fat_file_extend+0x1a4> <== NOT EXECUTED
00025324 <fat_file_ioctl>:
fat_file_ioctl(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
int cmd,
...)
{
25324: e92d000c push {r2, r3} <== NOT EXECUTED
25328: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
2532c: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
25330: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
25334: e3530001 cmp r3, #1 <== NOT EXECUTED
uint32_t cl_start = 0;
uint32_t pos = 0;
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
25338: e28d3018 add r3, sp, #24 <== NOT EXECUTED 2533c: e58d3000 str r3, [sp] <== NOT EXECUTED
int cmd,
...)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
25340: e3a02000 mov r2, #0 <== NOT EXECUTED 25344: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
fat_file_fd_t *fat_fd,
int cmd,
...)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
25348: e590c034 ldr ip, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t *ret;
va_list ap;
va_start(ap, cmd);
switch (cmd)
2534c: 0a000007 beq 25370 <fat_file_ioctl+0x4c> <== NOT EXECUTED
*ret = cur_cln;
break;
default:
errno = EINVAL;
25350: eb007726 bl 42ff0 <__errno> <== NOT EXECUTED 25354: e3a03016 mov r3, #22 <== NOT EXECUTED 25358: e5803000 str r3, [r0] <== NOT EXECUTED 2535c: e3e00000 mvn r0, #0 <== NOT EXECUTED
rc = -1;
break;
}
return rc;
}
25360: e28dd008 add sp, sp, #8 <== NOT EXECUTED
25364: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
25368: e28dd008 add sp, sp, #8 <== NOT EXECUTED
2536c: e12fff1e bx lr <== NOT EXECUTED
case F_CLU_NUM:
pos = va_arg(ap, uint32_t );
ret = va_arg(ap, uint32_t *);
/* sanity check */
if ( pos >= fat_fd->fat_file_size )
25370: e5914018 ldr r4, [r1, #24] <== NOT EXECUTED
va_start(ap, cmd);
switch (cmd)
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t );
25374: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
ret = va_arg(ap, uint32_t *);
25378: e2833008 add r3, r3, #8 <== NOT EXECUTED
/* sanity check */
if ( pos >= fat_fd->fat_file_size )
2537c: e1520004 cmp r2, r4 <== NOT EXECUTED
switch (cmd)
{
case F_CLU_NUM:
pos = va_arg(ap, uint32_t );
ret = va_arg(ap, uint32_t *);
25380: e58d3000 str r3, [sp] <== NOT EXECUTED 25384: e59d401c ldr r4, [sp, #28] <== NOT EXECUTED
/* sanity check */
if ( pos >= fat_fd->fat_file_size )
25388: 2a00001a bcs 253f8 <fat_file_ioctl+0xd4> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2538c: e5913020 ldr r3, [r1, #32] <== NOT EXECUTED 25390: e3530001 cmp r3, #1 <== NOT EXECUTED 25394: 0a000008 beq 253bc <fat_file_ioctl+0x98> <== NOT EXECUTED
return RC_OK;
}
cl_start = pos >> fs_info->vol.bpc_log2;
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
25398: e5dc3008 ldrb r3, [ip, #8] <== NOT EXECUTED 2539c: e1a02332 lsr r2, r2, r3 <== NOT EXECUTED 253a0: e28d3004 add r3, sp, #4 <== NOT EXECUTED 253a4: ebffff53 bl 250f8 <fat_file_lseek> <== NOT EXECUTED
if ( rc != RC_OK )
253a8: e3500000 cmp r0, #0 <== NOT EXECUTED 253ac: 1affffeb bne 25360 <fat_file_ioctl+0x3c> <== NOT EXECUTED
return rc;
*ret = cur_cln;
253b0: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 253b4: e5843000 str r3, [r4] <== NOT EXECUTED
break;
253b8: eaffffe8 b 25360 <fat_file_ioctl+0x3c> <== NOT EXECUTED
/* sanity check */
if ( pos >= fat_fd->fat_file_size )
rtems_set_errno_and_return_minus_one( EIO );
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
253bc: e5913024 ldr r3, [r1, #36] ; 0x24 <== NOT EXECUTED 253c0: e3530000 cmp r3, #0 <== NOT EXECUTED 253c4: 1afffff3 bne 25398 <fat_file_ioctl+0x74> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
253c8: e5dc500a ldrb r5, [ip, #10] <== NOT EXECUTED 253cc: e3150003 tst r5, #3 <== NOT EXECUTED
{
/* cluster 0 (zero) reserved for root dir */
*ret = 0;
253d0: 15843000 strne r3, [r4] <== NOT EXECUTED 253d4: 11a00003 movne r0, r3 <== NOT EXECUTED
/* sanity check */
if ( pos >= fat_fd->fat_file_size )
rtems_set_errno_and_return_minus_one( EIO );
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
253d8: 1affffe0 bne 25360 <fat_file_ioctl+0x3c> <== NOT EXECUTED
return RC_OK;
}
cl_start = pos >> fs_info->vol.bpc_log2;
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
253dc: e5dc3008 ldrb r3, [ip, #8] <== NOT EXECUTED 253e0: e1a02332 lsr r2, r2, r3 <== NOT EXECUTED 253e4: e28d3004 add r3, sp, #4 <== NOT EXECUTED 253e8: ebffff42 bl 250f8 <fat_file_lseek> <== NOT EXECUTED
if ( rc != RC_OK )
253ec: e3500000 cmp r0, #0 <== NOT EXECUTED 253f0: 0affffee beq 253b0 <fat_file_ioctl+0x8c> <== NOT EXECUTED 253f4: eaffffd9 b 25360 <fat_file_ioctl+0x3c> <== NOT EXECUTED
pos = va_arg(ap, uint32_t );
ret = va_arg(ap, uint32_t *);
/* sanity check */
if ( pos >= fat_fd->fat_file_size )
rtems_set_errno_and_return_minus_one( EIO );
253f8: eb0076fc bl 42ff0 <__errno> <== NOT EXECUTED 253fc: e3a03005 mov r3, #5 <== NOT EXECUTED 25400: e5803000 str r3, [r0] <== NOT EXECUTED 25404: e3e00000 mvn r0, #0 <== NOT EXECUTED 25408: eaffffd4 b 25360 <fat_file_ioctl+0x3c> <== NOT EXECUTED
000250f8 <fat_file_lseek>:
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
250f8: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
250fc: e5918034 ldr r8, [r1, #52] ; 0x34 <== NOT EXECUTED 25100: e1580002 cmp r8, r2 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t file_cln,
uint32_t *disk_cln
)
{
25104: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 25108: e1a05001 mov r5, r1 <== NOT EXECUTED 2510c: e1a06002 mov r6, r2 <== NOT EXECUTED 25110: e1a04000 mov r4, r0 <== NOT EXECUTED 25114: e1a09003 mov r9, r3 <== NOT EXECUTED
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
25118: 0a000020 beq 251a0 <fat_file_lseek+0xa8> <== NOT EXECUTED
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
2511c: 35911038 ldrcc r1, [r1, #56] ; 0x38 <== NOT EXECUTED
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
25120: 2595101c ldrcs r1, [r5, #28] <== NOT EXECUTED
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
count = file_cln - fat_fd->map.file_cln;
25124: 30688002 rsbcc r8, r8, r2 <== NOT EXECUTED
}
else
{
cur_cln = fat_fd->cln;
25128: 21a08002 movcs r8, r2 <== NOT EXECUTED
uint32_t count;
uint32_t i;
if (file_cln > fat_fd->map.file_cln)
{
cur_cln = fat_fd->map.disk_cln;
2512c: 358d1000 strcc r1, [sp] <== NOT EXECUTED
count = file_cln - fat_fd->map.file_cln;
}
else
{
cur_cln = fat_fd->cln;
25130: 258d1000 strcs r1, [sp] <== NOT EXECUTED
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
25134: e3580000 cmp r8, #0 <== NOT EXECUTED 25138: 0a000012 beq 25188 <fat_file_lseek+0x90> <== NOT EXECUTED 2513c: e3a07000 mov r7, #0 <== NOT EXECUTED 25140: e1a0a00d mov sl, sp <== NOT EXECUTED 25144: ea000002 b 25154 <fat_file_lseek+0x5c> <== NOT EXECUTED 25148: e1580007 cmp r8, r7 <== NOT EXECUTED 2514c: 9a00000c bls 25184 <fat_file_lseek+0x8c> <== NOT EXECUTED 25150: e59d1000 ldr r1, [sp] <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
25154: e1a00004 mov r0, r4 <== NOT EXECUTED 25158: e1a0200d mov r2, sp <== NOT EXECUTED 2515c: eb006731 bl 3ee28 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
25160: e3500000 cmp r0, #0 <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
25164: e2877001 add r7, r7, #1 <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
25168: 0afffff6 beq 25148 <fat_file_lseek+0x50> <== NOT EXECUTED
return rc;
2516c: e1a03000 mov r3, r0 <== NOT EXECUTED 25170: e1a04fc3 asr r4, r3, #31 <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
*disk_cln = cur_cln;
}
return RC_OK;
}
25174: e1a01004 mov r1, r4 <== NOT EXECUTED
25178: e1a00003 mov r0, r3 <== NOT EXECUTED
2517c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
25180: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
cur_cln = fat_fd->cln;
count = file_cln;
}
/* skip over the clusters */
for (i = 0; i < count; i++)
25184: e59d1000 ldr r1, [sp] <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
}
/* update cache */
fat_fd->map.file_cln = file_cln;
25188: e5856034 str r6, [r5, #52] ; 0x34 <== NOT EXECUTED
fat_fd->map.disk_cln = cur_cln;
2518c: e5851038 str r1, [r5, #56] ; 0x38 <== NOT EXECUTED
*disk_cln = cur_cln;
25190: e3a03000 mov r3, #0 <== NOT EXECUTED 25194: e5891000 str r1, [r9] <== NOT EXECUTED 25198: e3a04000 mov r4, #0 <== NOT EXECUTED 2519c: eafffff4 b 25174 <fat_file_lseek+0x7c> <== NOT EXECUTED
)
{
int rc = RC_OK;
if (file_cln == fat_fd->map.file_cln)
*disk_cln = fat_fd->map.disk_cln;
251a0: e5913038 ldr r3, [r1, #56] ; 0x38 <== NOT EXECUTED 251a4: e3a04000 mov r4, #0 <== NOT EXECUTED 251a8: e5893000 str r3, [r9] <== NOT EXECUTED 251ac: e3a03000 mov r3, #0 <== NOT EXECUTED 251b0: eaffffef b 25174 <fat_file_lseek+0x7c> <== NOT EXECUTED
000252d4 <fat_file_mark_removed>:
static inline uint32_t
fat_construct_key(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
252d4: e5913020 ldr r3, [r1, #32] <== NOT EXECUTED
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
252d8: e3530001 cmp r3, #1 <== NOT EXECUTED
void
fat_file_mark_removed(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
252dc: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
252e0: e1a04001 mov r4, r1 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
252e4: e5905034 ldr r5, [r0, #52] ; 0x34 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
252e8: e5946024 ldr r6, [r4, #36] ; 0x24 <== NOT EXECUTED 252ec: e1a062a6 lsr r6, r6, #5 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
252f0: e1a00004 mov r0, r4 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
252f4: e2066001 and r6, r6, #1 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
252f8: ebff9f6c bl d0b0 <_Chain_Extract> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
252fc: e5953068 ldr r3, [r5, #104] ; 0x68 <== NOT EXECUTED 25300: e1a02086 lsl r2, r6, #1 <== NOT EXECUTED 25304: e0826006 add r6, r2, r6 <== NOT EXECUTED 25308: e0830106 add r0, r3, r6, lsl #2 <== NOT EXECUTED 2530c: e1a01004 mov r1, r4 <== NOT EXECUTED 25310: ebff9f5b bl d084 <_Chain_Append> <== NOT EXECUTED
_hash_delete(fs_info->vhash, key, fat_fd->ino, fat_fd);
_hash_insert(fs_info->rhash, key, fat_fd->ino, fat_fd);
fat_fd->flags |= FAT_FILE_REMOVED;
25314: e5d43030 ldrb r3, [r4, #48] ; 0x30 <== NOT EXECUTED 25318: e3833001 orr r3, r3, #1 <== NOT EXECUTED 2531c: e5c43030 strb r3, [r4, #48] ; 0x30 <== NOT EXECUTED
}
25320: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00025c00 <fat_file_open>:
fat_file_open(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
fat_file_fd_t **fat_fd
)
{
25c00: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
static inline uint32_t
fat_construct_key(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
25c04: e5915000 ldr r5, [r1] <== NOT EXECUTED
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
25c08: e3550001 cmp r5, #1 <== NOT EXECUTED 25c0c: e1a08001 mov r8, r1 <== NOT EXECUTED 25c10: e1a0a000 mov sl, r0 <== NOT EXECUTED 25c14: e1a09002 mov r9, r2 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
25c18: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED 25c1c: 0a000007 beq 25c40 <fat_file_open+0x40> <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25c20: e3550000 cmp r5, #0 <== NOT EXECUTED 25c24: 0a00005b beq 25d98 <fat_file_open+0x198> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
25c28: e5d42005 ldrb r2, [r4, #5] <== NOT EXECUTED 25c2c: e5943030 ldr r3, [r4, #48] ; 0x30 <== NOT EXECUTED 25c30: e2455002 sub r5, r5, #2 <== NOT EXECUTED 25c34: e0835215 add r5, r3, r5, lsl r2 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(mt_entry, cln) <<
25c38: e5d43003 ldrb r3, [r4, #3] <== NOT EXECUTED 25c3c: e1a05315 lsl r5, r5, r3 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
25c40: e5983004 ldr r3, [r8, #4] <== NOT EXECUTED
static inline uint32_t
fat_construct_key(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
25c44: e1a022a3 lsr r2, r3, #5 <== NOT EXECUTED 25c48: e08554a3 add r5, r5, r3, lsr #9 <== NOT EXECUTED 25c4c: e202200f and r2, r2, #15 <== NOT EXECUTED 25c50: e0825205 add r5, r2, r5, lsl #4 <== NOT EXECUTED
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = ((rtems_chain_control *)((hash) + mod))->first;
25c54: e2053001 and r3, r5, #1 <== NOT EXECUTED 25c58: e1a07083 lsl r7, r3, #1 <== NOT EXECUTED 25c5c: e0877003 add r7, r7, r3 <== NOT EXECUTED 25c60: e594c064 ldr ip, [r4, #100] ; 0x64 <== NOT EXECUTED 25c64: e1a07107 lsl r7, r7, #2 <== NOT EXECUTED 25c68: e79c3007 ldr r3, [ip, r7] <== NOT EXECUTED 25c6c: e08cc007 add ip, ip, r7 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
25c70: e28cc004 add ip, ip, #4 <== NOT EXECUTED
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
25c74: e15c0003 cmp ip, r3 <== NOT EXECUTED 25c78: 1a000003 bne 25c8c <fat_file_open+0x8c> <== NOT EXECUTED 25c7c: ea00001e b 25cfc <fat_file_open+0xfc> <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
25c80: e5933000 ldr r3, [r3] <== NOT EXECUTED
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = ((rtems_chain_control *)((hash) + mod))->first;
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
25c84: e15c0003 cmp ip, r3 <== NOT EXECUTED 25c88: 0a00001b beq 25cfc <fat_file_open+0xfc> <== NOT EXECUTED 25c8c: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
25c90: e3520001 cmp r2, #1 <== NOT EXECUTED
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
25c94: e2420002 sub r0, r2, #2 <== NOT EXECUTED
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
25c98: 0a00000a beq 25cc8 <fat_file_open+0xc8> <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25c9c: e3520000 cmp r2, #0 <== NOT EXECUTED 25ca0: 1a000003 bne 25cb4 <fat_file_open+0xb4> <== NOT EXECUTED 25ca4: e5d4200a ldrb r2, [r4, #10] <== NOT EXECUTED 25ca8: e3120003 tst r2, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
25cac: 1594201c ldrne r2, [r4, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25cb0: 1a000002 bne 25cc0 <fat_file_open+0xc0> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
25cb4: e5d41005 ldrb r1, [r4, #5] <== NOT EXECUTED 25cb8: e5942030 ldr r2, [r4, #48] ; 0x30 <== NOT EXECUTED 25cbc: e0822110 add r2, r2, r0, lsl r1 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(mt_entry, cln) <<
25cc0: e5d46003 ldrb r6, [r4, #3] <== NOT EXECUTED 25cc4: e1a02612 lsl r2, r2, r6 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
25cc8: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(mt_entry, &ffd->dir_pos.sname);
if ( (key1) == ck)
25ccc: e1a002a1 lsr r0, r1, #5 <== NOT EXECUTED 25cd0: e200000f and r0, r0, #15 <== NOT EXECUTED 25cd4: e08214a1 add r1, r2, r1, lsr #9 <== NOT EXECUTED 25cd8: e0801201 add r1, r0, r1, lsl #4 <== NOT EXECUTED 25cdc: e1550001 cmp r5, r1 <== NOT EXECUTED 25ce0: 1affffe6 bne 25c80 <fat_file_open+0x80> <== NOT EXECUTED
rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
if ( rc == RC_OK )
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
lfat_fd->links_num++;
25ce4: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED 25ce8: e2822001 add r2, r2, #1 <== NOT EXECUTED 25cec: e5832008 str r2, [r3, #8] <== NOT EXECUTED
/* access "valid" hash table */
rc = _hash_search(mt_entry, fs_info->vhash, key, 0, &lfat_fd);
if ( rc == RC_OK )
{
/* return pointer to fat_file_descriptor allocated before */
(*fat_fd) = lfat_fd;
25cf0: e5893000 str r3, [r9] <== NOT EXECUTED
lfat_fd->links_num++;
25cf4: e3a00000 mov r0, #0 <== NOT EXECUTED
return rc;
25cf8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
uint32_t key2,
fat_file_fd_t **ret
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = ((rtems_chain_control *)((hash) + mod))->first;
25cfc: e594c068 ldr ip, [r4, #104] ; 0x68 <== NOT EXECUTED 25d00: e79c3007 ldr r3, [ip, r7] <== NOT EXECUTED 25d04: e08cc007 add ip, ip, r7 <== NOT EXECUTED 25d08: e28cc004 add ip, ip, #4 <== NOT EXECUTED
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
25d0c: e153000c cmp r3, ip <== NOT EXECUTED 25d10: 1a000009 bne 25d3c <fat_file_open+0x13c> <== NOT EXECUTED 25d14: e3e0b000 mvn fp, #0 <== NOT EXECUTED 25d18: ea000024 b 25db0 <fat_file_open+0x1b0> <== NOT EXECUTED
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(mt_entry, &ffd->dir_pos.sname);
if ( (key1) == ck)
{
if ( ((key2) == 0) || ((key2) == ffd->ino) )
25d1c: e3550000 cmp r5, #0 <== NOT EXECUTED 25d20: 0a000021 beq 25dac <fat_file_open+0x1ac> <== NOT EXECUTED 25d24: e593200c ldr r2, [r3, #12] <== NOT EXECUTED 25d28: e1550002 cmp r5, r2 <== NOT EXECUTED 25d2c: 0a00001e beq 25dac <fat_file_open+0x1ac> <== NOT EXECUTED
{
*ret = (void *)the_node;
return 0;
}
}
the_node = the_node->next;
25d30: e5933000 ldr r3, [r3] <== NOT EXECUTED
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = ((rtems_chain_control *)((hash) + mod))->first;
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
25d34: e15c0003 cmp ip, r3 <== NOT EXECUTED 25d38: 0afffff5 beq 25d14 <fat_file_open+0x114> <== NOT EXECUTED
static inline uint32_t
fat_construct_key(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_pos_t *pos)
{
return ( ((fat_cluster_num_to_sector512_num(mt_entry, pos->cln) +
25d3c: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED
uint32_t cln
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
25d40: e3520001 cmp r2, #1 <== NOT EXECUTED 25d44: 0a00000b beq 25d78 <fat_file_open+0x178> <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25d48: e3520000 cmp r2, #0 <== NOT EXECUTED 25d4c: 1a000003 bne 25d60 <fat_file_open+0x160> <== NOT EXECUTED 25d50: e5d4100a ldrb r1, [r4, #10] <== NOT EXECUTED 25d54: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
25d58: 1594201c ldrne r2, [r4, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25d5c: 1a000003 bne 25d70 <fat_file_open+0x170> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
25d60: e5d41005 ldrb r1, [r4, #5] <== NOT EXECUTED 25d64: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED 25d68: e2422002 sub r2, r2, #2 <== NOT EXECUTED 25d6c: e0802112 add r2, r0, r2, lsl r1 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
if (cln == 1)
return 1;
return (fat_cluster_num_to_sector_num(mt_entry, cln) <<
25d70: e5d40003 ldrb r0, [r4, #3] <== NOT EXECUTED 25d74: e1a02012 lsl r2, r2, r0 <== NOT EXECUTED
(pos->ofs >> FAT_SECTOR512_BITS)) << 4) +
25d78: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED
{
fat_file_fd_t *ffd = (fat_file_fd_t *)the_node;
uint32_t ck = fat_construct_key(mt_entry, &ffd->dir_pos.sname);
if ( (key1) == ck)
25d7c: e1a002a1 lsr r0, r1, #5 <== NOT EXECUTED 25d80: e200000f and r0, r0, #15 <== NOT EXECUTED 25d84: e08214a1 add r1, r2, r1, lsr #9 <== NOT EXECUTED 25d88: e0801201 add r1, r0, r1, lsl #4 <== NOT EXECUTED 25d8c: e1550001 cmp r5, r1 <== NOT EXECUTED 25d90: 1affffe6 bne 25d30 <fat_file_open+0x130> <== NOT EXECUTED 25d94: eaffffe0 b 25d1c <fat_file_open+0x11c> <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25d98: e5d4300a ldrb r3, [r4, #10] <== NOT EXECUTED 25d9c: e3130003 tst r3, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
25da0: 1594501c ldrne r5, [r4, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25da4: 1affffa3 bne 25c38 <fat_file_open+0x38> <== NOT EXECUTED 25da8: eaffff9e b 25c28 <fat_file_open+0x28> <== NOT EXECUTED
)
{
uint32_t mod = (key1) % FAT_HASH_MODULE;
rtems_chain_node *the_node = ((rtems_chain_control *)((hash) + mod))->first;
for ( ; !rtems_chain_is_tail((hash) + mod, the_node) ; )
25dac: e3a0b000 mov fp, #0 <== NOT EXECUTED
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
25db0: e3a00044 mov r0, #68 ; 0x44 <== NOT EXECUTED 25db4: ebff89b1 bl 8480 <malloc> <== NOT EXECUTED
if ( lfat_fd == NULL )
25db8: e3500000 cmp r0, #0 <== NOT EXECUTED
}
/* access "removed-but-still-open" hash table */
rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
25dbc: e1a06000 mov r6, r0 <== NOT EXECUTED 25dc0: e5890000 str r0, [r9] <== NOT EXECUTED
if ( lfat_fd == NULL )
25dc4: 0a000021 beq 25e50 <fat_file_open+0x250> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
25dc8: e3a01000 mov r1, #0 <== NOT EXECUTED 25dcc: e3a02044 mov r2, #68 ; 0x44 <== NOT EXECUTED 25dd0: eb0081bd bl 464cc <memset> <== NOT EXECUTED
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
25dd4: e5d6c030 ldrb ip, [r6, #48] ; 0x30 <== NOT EXECUTED
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
25dd8: e898000f ldm r8, {r0, r1, r2, r3} <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
25ddc: e3cce001 bic lr, ip, #1 <== NOT EXECUTED
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
25de0: e286c020 add ip, r6, #32 <== NOT EXECUTED
if ( rc != RC_OK )
25de4: e35b0000 cmp fp, #0 <== NOT EXECUTED
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
25de8: e3e08000 mvn r8, #0 <== NOT EXECUTED
lfat_fd->dir_pos = *dir_pos;
25dec: e88c000f stm ip, {r0, r1, r2, r3} <== NOT EXECUTED
if ( lfat_fd == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
memset(lfat_fd, 0, sizeof(fat_file_fd_t));
lfat_fd->links_num = 1;
25df0: e3a03001 mov r3, #1 <== NOT EXECUTED 25df4: e5863008 str r3, [r6, #8] <== NOT EXECUTED
lfat_fd->flags &= ~FAT_FILE_REMOVED;
25df8: e5c6e030 strb lr, [r6, #48] ; 0x30 <== NOT EXECUTED
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
25dfc: e586803c str r8, [r6, #60] ; 0x3c <== NOT EXECUTED
lfat_fd->dir_pos = *dir_pos;
if ( rc != RC_OK )
lfat_fd->ino = key;
25e00: 1586500c strne r5, [r6, #12] <== NOT EXECUTED
lfat_fd->flags &= ~FAT_FILE_REMOVED;
lfat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
lfat_fd->dir_pos = *dir_pos;
if ( rc != RC_OK )
25e04: 0a000005 beq 25e20 <fat_file_open+0x220> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
25e08: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED 25e0c: e1a01006 mov r1, r6 <== NOT EXECUTED 25e10: e0800007 add r0, r0, r7 <== NOT EXECUTED 25e14: ebff9c9a bl d084 <_Chain_Append> <== NOT EXECUTED 25e18: e3a00000 mov r0, #0 <== NOT EXECUTED
* other fields of fat-file descriptor will be initialized on upper
* level
*/
return RC_OK;
}
25e1c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if ( rc != RC_OK )
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(mt_entry);
25e20: e1a0000a mov r0, sl <== NOT EXECUTED 25e24: eb00001e bl 25ea4 <fat_get_unique_ino> <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
25e28: e3500000 cmp r0, #0 <== NOT EXECUTED
if ( rc != RC_OK )
lfat_fd->ino = key;
else
{
lfat_fd->ino = fat_get_unique_ino(mt_entry);
25e2c: e586000c str r0, [r6, #12] <== NOT EXECUTED
if ( lfat_fd->ino == 0 )
25e30: 1afffff4 bne 25e08 <fat_file_open+0x208> <== NOT EXECUTED
{
free((*fat_fd));
25e34: e5990000 ldr r0, [r9] <== NOT EXECUTED 25e38: ebff87cc bl 7d70 <free> <== NOT EXECUTED
/*
* XXX: kernel resource is unsufficient, but not the memory,
* but there is no suitable errno :(
*/
rtems_set_errno_and_return_minus_one( ENOMEM );
25e3c: eb00746b bl 42ff0 <__errno> <== NOT EXECUTED
25e40: e3a0300c mov r3, #12 <== NOT EXECUTED
25e44: e5803000 str r3, [r0] <== NOT EXECUTED
25e48: e1a00008 mov r0, r8 <== NOT EXECUTED
25e4c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/* access "removed-but-still-open" hash table */
rc = _hash_search(mt_entry, fs_info->rhash, key, key, &lfat_fd);
lfat_fd = (*fat_fd) = (fat_file_fd_t*)malloc(sizeof(fat_file_fd_t));
if ( lfat_fd == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
25e50: eb007466 bl 42ff0 <__errno> <== NOT EXECUTED
25e54: e3a0300c mov r3, #12 <== NOT EXECUTED
25e58: e5803000 str r3, [r0] <== NOT EXECUTED
25e5c: e3e00000 mvn r0, #0 <== NOT EXECUTED
25e60: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0002594c <fat_file_read>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
2594c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
/* it couldn't be removed - otherwise cache update will be broken */
if (count == 0)
25950: e2535000 subs r5, r3, #0 <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
uint8_t *buf
)
{
25954: e24dd014 sub sp, sp, #20 <== NOT EXECUTED 25958: e1a06000 mov r6, r0 <== NOT EXECUTED 2595c: e1a0a001 mov sl, r1 <== NOT EXECUTED 25960: e1a04002 mov r4, r2 <== NOT EXECUTED
int rc = RC_OK;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
25964: e5907034 ldr r7, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
/* it couldn't be removed - otherwise cache update will be broken */
if (count == 0)
25968: 0a00004d beq 25aa4 <fat_file_read+0x158> <== NOT EXECUTED
/*
* >= because start is offset and computed from 0 and file_size
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
2596c: e5913018 ldr r3, [r1, #24] <== NOT EXECUTED 25970: e1530002 cmp r3, r2 <== NOT EXECUTED 25974: 9a00004a bls 25aa4 <fat_file_read+0x158> <== NOT EXECUTED
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
25978: e1550003 cmp r5, r3 <== NOT EXECUTED 2597c: 9a00004b bls 25ab0 <fat_file_read+0x164> <== NOT EXECUTED
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
25980: e0645003 rsb r5, r4, r3 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
25984: e59a3020 ldr r3, [sl, #32] <== NOT EXECUTED 25988: e3530001 cmp r3, #1 <== NOT EXECUTED
{
int rc = RC_OK;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
2598c: e3a03000 mov r3, #0 <== NOT EXECUTED 25990: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
if ((count > fat_fd->fat_file_size) ||
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
25994: 0a000049 beq 25ac0 <fat_file_read+0x174> <== NOT EXECUTED
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
25998: e5d73008 ldrb r3, [r7, #8] <== NOT EXECUTED 2599c: e1a03334 lsr r3, r4, r3 <== NOT EXECUTED
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
259a0: e28db010 add fp, sp, #16 <== NOT EXECUTED
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
259a4: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
259a8: e1a02003 mov r2, r3 <== NOT EXECUTED 259ac: e1a00006 mov r0, r6 <== NOT EXECUTED 259b0: e1a0100a mov r1, sl <== NOT EXECUTED 259b4: e1a0300b mov r3, fp <== NOT EXECUTED
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
259b8: e1d790b6 ldrh r9, [r7, #6] <== NOT EXECUTED
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
259bc: ebfffdcd bl 250f8 <fat_file_lseek> <== NOT EXECUTED
if (rc != RC_OK)
259c0: e2508000 subs r8, r0, #0 <== NOT EXECUTED 259c4: 11a00008 movne r0, r8 <== NOT EXECUTED 259c8: 1a000036 bne 25aa8 <fat_file_read+0x15c> <== NOT EXECUTED
return rc;
while (count > 0)
259cc: e3550000 cmp r5, #0 <== NOT EXECUTED
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
259d0: e2499001 sub r9, r9, #1 <== NOT EXECUTED 259d4: e0049009 and r9, r4, r9 <== NOT EXECUTED
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
259d8: 01a00005 moveq r0, r5 <== NOT EXECUTED
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
259dc: e58d9008 str r9, [sp, #8] <== NOT EXECUTED
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
259e0: 01a08000 moveq r8, r0 <== NOT EXECUTED 259e4: 01a09000 moveq r9, r0 <== NOT EXECUTED 259e8: 0a000051 beq 25b34 <fat_file_read+0x1e8> <== NOT EXECUTED
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
259ec: e5d79002 ldrb r9, [r7, #2] <== NOT EXECUTED 259f0: e1d720b0 ldrh r2, [r7] <== NOT EXECUTED 259f4: e58da00c str sl, [sp, #12] <== NOT EXECUTED 259f8: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 259fc: e59da038 ldr sl, [sp, #56] ; 0x38 <== NOT EXECUTED 25a00: ea000003 b 25a14 <fat_file_read+0xc8> <== NOT EXECUTED
return rc;
while (count > 0)
25a04: e0555004 subs r5, r5, r4 <== NOT EXECUTED 25a08: 0a000047 beq 25b2c <fat_file_read+0x1e0> <== NOT EXECUTED 25a0c: e5d79002 ldrb r9, [r7, #2] <== NOT EXECUTED 25a10: e1d720b0 ldrh r2, [r7] <== NOT EXECUTED
{
c = MIN(count, (fs_info->vol.bpc - ofs));
25a14: e1d740b6 ldrh r4, [r7, #6] <== NOT EXECUTED
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
25a18: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
25a1c: e0614004 rsb r4, r1, r4 <== NOT EXECUTED 25a20: e1540005 cmp r4, r5 <== NOT EXECUTED 25a24: 21a04005 movcs r4, r5 <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25a28: e3500000 cmp r0, #0 <== NOT EXECUTED
fat_cluster_num_to_sector_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
25a2c: e5963034 ldr r3, [r6, #52] ; 0x34 <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
25a30: e2400002 sub r0, r0, #2 <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25a34: 1a000003 bne 25a48 <fat_file_read+0xfc> <== NOT EXECUTED 25a38: e5d3c00a ldrb ip, [r3, #10] <== NOT EXECUTED 25a3c: e31c0003 tst ip, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
25a40: 1593e01c ldrne lr, [r3, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25a44: 1a000002 bne 25a54 <fat_file_read+0x108> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
25a48: e593c030 ldr ip, [r3, #48] ; 0x30 <== NOT EXECUTED 25a4c: e5d3e005 ldrb lr, [r3, #5] <== NOT EXECUTED 25a50: e08cee10 add lr, ip, r0, lsl lr <== NOT EXECUTED
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
25a54: e2422001 sub r2, r2, #1 <== NOT EXECUTED 25a58: e0022001 and r2, r2, r1 <== NOT EXECUTED 25a5c: e08ac008 add ip, sl, r8 <== NOT EXECUTED 25a60: e1a03004 mov r3, r4 <== NOT EXECUTED 25a64: e1a00006 mov r0, r6 <== NOT EXECUTED 25a68: e08e1931 add r1, lr, r1, lsr r9 <== NOT EXECUTED 25a6c: e58dc000 str ip, [sp] <== NOT EXECUTED 25a70: eb0002f4 bl 26648 <_fat_block_read> <== NOT EXECUTED
if ( ret < 0 )
25a74: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
count -= c;
cmpltd += c;
25a78: e0888004 add r8, r8, r4 <== NOT EXECUTED
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
25a7c: e1a0200b mov r2, fp <== NOT EXECUTED 25a80: e1a00006 mov r0, r6 <== NOT EXECUTED
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
25a84: ba000026 blt 25b24 <fat_file_read+0x1d8> <== NOT EXECUTED
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
25a88: e59d9010 ldr r9, [sp, #16] <== NOT EXECUTED
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
25a8c: e1a01009 mov r1, r9 <== NOT EXECUTED 25a90: eb0064e4 bl 3ee28 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
25a94: e2501000 subs r1, r0, #0 <== NOT EXECUTED 25a98: 0affffd9 beq 25a04 <fat_file_read+0xb8> <== NOT EXECUTED 25a9c: e1a00001 mov r0, r1 <== NOT EXECUTED 25aa0: ea000000 b 25aa8 <fat_file_read+0x15c> <== NOT EXECUTED
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
25aa4: e3a00000 mov r0, #0 <== NOT EXECUTED
}
25aa8: e28dd014 add sp, sp, #20 <== NOT EXECUTED
25aac: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* computed from 1
*/
if ( start >= fat_fd->fat_file_size )
return FAT_EOF;
if ((count > fat_fd->fat_file_size) ||
25ab0: e0652003 rsb r2, r5, r3 <== NOT EXECUTED 25ab4: e1540002 cmp r4, r2 <== NOT EXECUTED 25ab8: 9affffb1 bls 25984 <fat_file_read+0x38> <== NOT EXECUTED 25abc: eaffffaf b 25980 <fat_file_read+0x34> <== NOT EXECUTED
(start > fat_fd->fat_file_size - count))
count = fat_fd->fat_file_size - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
25ac0: e59a3024 ldr r3, [sl, #36] ; 0x24 <== NOT EXECUTED 25ac4: e3530000 cmp r3, #0 <== NOT EXECUTED 25ac8: 1affffb2 bne 25998 <fat_file_read+0x4c> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
25acc: e5d7300a ldrb r3, [r7, #10] <== NOT EXECUTED 25ad0: e3130003 tst r3, #3 <== NOT EXECUTED 25ad4: 0affffaf beq 25998 <fat_file_read+0x4c> <== NOT EXECUTED
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
25ad8: e59a301c ldr r3, [sl, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25adc: e3530000 cmp r3, #0 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
25ae0: 15d71005 ldrbne r1, [r7, #5] <== NOT EXECUTED 25ae4: 15972030 ldrne r2, [r7, #48] ; 0x30 <== NOT EXECUTED 25ae8: 12433002 subne r3, r3, #2 <== NOT EXECUTED 25aec: 10823113 addne r3, r2, r3, lsl r1 <== NOT EXECUTED
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_read(mt_entry, sec, byte, count, buf);
25af0: e1d720b0 ldrh r2, [r7] <== NOT EXECUTED
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
25af4: 0597301c ldreq r3, [r7, #28] <== NOT EXECUTED 25af8: e5d71002 ldrb r1, [r7, #2] <== NOT EXECUTED 25afc: e59dc038 ldr ip, [sp, #56] ; 0x38 <== NOT EXECUTED 25b00: e2422001 sub r2, r2, #1 <== NOT EXECUTED 25b04: e0831134 add r1, r3, r4, lsr r1 <== NOT EXECUTED 25b08: e0042002 and r2, r4, r2 <== NOT EXECUTED 25b0c: e1a00006 mov r0, r6 <== NOT EXECUTED 25b10: e1a03005 mov r3, r5 <== NOT EXECUTED 25b14: e58dc000 str ip, [sp] <== NOT EXECUTED 25b18: eb0002ca bl 26648 <_fat_block_read> <== NOT EXECUTED
if ( ret < 0 )
25b1c: e3500000 cmp r0, #0 <== NOT EXECUTED 25b20: aaffffe0 bge 25aa8 <fat_file_read+0x15c> <== NOT EXECUTED
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
25b24: e3e00000 mvn r0, #0 <== NOT EXECUTED 25b28: eaffffde b 25aa8 <fat_file_read+0x15c> <== NOT EXECUTED 25b2c: e59da00c ldr sl, [sp, #12] <== NOT EXECUTED
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
25b30: e1a00008 mov r0, r8 <== NOT EXECUTED
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
25b34: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 25b38: e5d73008 ldrb r3, [r7, #8] <== NOT EXECUTED 25b3c: e2424001 sub r4, r2, #1 <== NOT EXECUTED 25b40: e59dc004 ldr ip, [sp, #4] <== NOT EXECUTED 25b44: e0848008 add r8, r4, r8 <== NOT EXECUTED 25b48: e08c8338 add r8, ip, r8, lsr r3 <== NOT EXECUTED
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
25b4c: e58a9038 str r9, [sl, #56] ; 0x38 <== NOT EXECUTED
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
25b50: e58a8034 str r8, [sl, #52] ; 0x34 <== NOT EXECUTED
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
25b54: eaffffd3 b 25aa8 <fat_file_read+0x15c> <== NOT EXECUTED
00025018 <fat_file_reopen>:
* RC_OK
*/
int
fat_file_reopen(fat_file_fd_t *fat_fd)
{
fat_fd->links_num++;
25018: e5903008 ldr r3, [r0, #8] <== NOT EXECUTED 2501c: e2833001 add r3, r3, #1 <== NOT EXECUTED 25020: e5803008 str r3, [r0, #8] <== NOT EXECUTED
return RC_OK;
}
25024: e3a00000 mov r0, #0 <== NOT EXECUTED 25028: e12fff1e bx lr <== NOT EXECUTED
0002502c <fat_file_size>:
int
fat_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
2502c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
25030: e5913020 ldr r3, [r1, #32] <== NOT EXECUTED 25034: e3530001 cmp r3, #1 <== NOT EXECUTED
int
fat_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
25038: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 2503c: e1a05001 mov r5, r1 <== NOT EXECUTED 25040: e1a08000 mov r8, r0 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
25044: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t cur_cln = fat_fd->cln;
25048: e591601c ldr r6, [r1, #28] <== NOT EXECUTED
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2504c: 0a000020 beq 250d4 <fat_file_size+0xa8> <== NOT EXECUTED
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
return rc;
}
fat_fd->fat_file_size = 0;
25050: e3a03000 mov r3, #0 <== NOT EXECUTED 25054: e5853018 str r3, [r5, #24] <== NOT EXECUTED
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
25058: e284100c add r1, r4, #12 <== NOT EXECUTED
2505c: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
25060: e0061001 and r1, r6, r1 <== NOT EXECUTED
25064: e1510002 cmp r1, r2 <== NOT EXECUTED
25068: 2a000015 bcs 250c4 <fat_file_size+0x98> <== NOT EXECUTED
fat_file_fd_t *fat_fd
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
2506c: e28d7004 add r7, sp, #4 <== NOT EXECUTED 25070: e5276004 str r6, [r7, #-4]! <== NOT EXECUTED 25074: ea00000a b 250a4 <fat_file_size+0x78> <== NOT EXECUTED
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
25078: e5952018 ldr r2, [r5, #24] <== NOT EXECUTED 2507c: e1d430b6 ldrh r3, [r4, #6] <== NOT EXECUTED 25080: e0823003 add r3, r2, r3 <== NOT EXECUTED 25084: e5853018 str r3, [r5, #24] <== NOT EXECUTED
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
25088: e59d3000 ldr r3, [sp] <== NOT EXECUTED
2508c: e284100c add r1, r4, #12 <== NOT EXECUTED
25090: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
25094: e0031001 and r1, r3, r1 <== NOT EXECUTED
25098: e1510002 cmp r1, r2 <== NOT EXECUTED
2509c: 2a000009 bcs 250c8 <fat_file_size+0x9c> <== NOT EXECUTED
250a0: e1a06003 mov r6, r3 <== NOT EXECUTED
{
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
250a4: e1a01006 mov r1, r6 <== NOT EXECUTED 250a8: e1a00008 mov r0, r8 <== NOT EXECUTED 250ac: e1a0200d mov r2, sp <== NOT EXECUTED 250b0: eb00675c bl 3ee28 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
250b4: e3500000 cmp r0, #0 <== NOT EXECUTED 250b8: 0affffee beq 25078 <fat_file_size+0x4c> <== NOT EXECUTED
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
return rc;
}
250bc: e28dd004 add sp, sp, #4 <== NOT EXECUTED
250c0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return rc;
}
fat_fd->fat_file_size = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
250c4: e1a06003 mov r6, r3 <== NOT EXECUTED
if ( rc != RC_OK )
return rc;
fat_fd->fat_file_size += fs_info->vol.bpc;
}
fat_fd->map.last_cln = save_cln;
250c8: e585603c str r6, [r5, #60] ; 0x3c <== NOT EXECUTED 250cc: e3a00000 mov r0, #0 <== NOT EXECUTED
return rc;
250d0: eafffff9 b 250bc <fat_file_size+0x90> <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = fat_fd->cln;
uint32_t save_cln = 0;
/* Have we requested root dir size for FAT12/16? */
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
250d4: e5910024 ldr r0, [r1, #36] ; 0x24 <== NOT EXECUTED 250d8: e3500000 cmp r0, #0 <== NOT EXECUTED 250dc: 1affffdb bne 25050 <fat_file_size+0x24> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
250e0: e5d4300a ldrb r3, [r4, #10] <== NOT EXECUTED 250e4: e3130003 tst r3, #3 <== NOT EXECUTED 250e8: 0affffd8 beq 25050 <fat_file_size+0x24> <== NOT EXECUTED
{
fat_fd->fat_file_size = fs_info->vol.rdir_size;
250ec: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 250f0: e5813018 str r3, [r1, #24] <== NOT EXECUTED
return rc;
250f4: eafffff0 b 250bc <fat_file_size+0x90> <== NOT EXECUTED
0002540c <fat_file_truncate>:
fat_file_truncate(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
2540c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
25410: e5913018 ldr r3, [r1, #24] <== NOT EXECUTED 25414: e1530002 cmp r3, r2 <== NOT EXECUTED
fat_file_truncate(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
uint32_t new_length
)
{
25418: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 2541c: e1a05001 mov r5, r1 <== NOT EXECUTED 25420: e1a04000 mov r4, r0 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
25424: e590c034 ldr ip, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
if ( new_length >= fat_fd->fat_file_size )
25428: 9a00002d bls 254e4 <fat_file_truncate+0xd8> <== NOT EXECUTED
uint32_t new_length
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
2542c: e3a06000 mov r6, #0 <== NOT EXECUTED 25430: e58d6004 str r6, [sp, #4] <== NOT EXECUTED
if ( new_length >= fat_fd->fat_file_size )
return rc;
assert(fat_fd->fat_file_size);
25434: e3530000 cmp r3, #0 <== NOT EXECUTED
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = 0;
uint32_t cl_start = 0;
uint32_t new_last_cln = FAT_UNDEFINED_VALUE;
25438: e3e06000 mvn r6, #0 <== NOT EXECUTED 2543c: e58d6000 str r6, [sp] <== NOT EXECUTED
if ( new_length >= fat_fd->fat_file_size )
return rc;
assert(fat_fd->fat_file_size);
25440: 0a00002a beq 254f0 <fat_file_truncate+0xe4> <== NOT EXECUTED
cl_start = (new_length + fs_info->vol.bpc - 1) >> fs_info->vol.bpc_log2;
25444: e1dc60b6 ldrh r6, [ip, #6] <== NOT EXECUTED 25448: e5dcc008 ldrb ip, [ip, #8] <== NOT EXECUTED 2544c: e2466001 sub r6, r6, #1 <== NOT EXECUTED 25450: e0866002 add r6, r6, r2 <== NOT EXECUTED 25454: e1a06c36 lsr r6, r6, ip <== NOT EXECUTED
if ((cl_start << fs_info->vol.bpc_log2) >= fat_fd->fat_file_size)
25458: e1530c16 cmp r3, r6, lsl ip <== NOT EXECUTED 2545c: 9a000020 bls 254e4 <fat_file_truncate+0xd8> <== NOT EXECUTED
return RC_OK;
if (cl_start != 0)
25460: e3560000 cmp r6, #0 <== NOT EXECUTED 25464: 0a000004 beq 2547c <fat_file_truncate+0x70> <== NOT EXECUTED
{
rc = fat_file_lseek(mt_entry, fat_fd, cl_start - 1, &new_last_cln);
25468: e2462001 sub r2, r6, #1 <== NOT EXECUTED 2546c: e1a0300d mov r3, sp <== NOT EXECUTED 25470: ebffff20 bl 250f8 <fat_file_lseek> <== NOT EXECUTED
if (rc != RC_OK)
25474: e3500000 cmp r0, #0 <== NOT EXECUTED 25478: 1a00001a bne 254e8 <fat_file_truncate+0xdc> <== NOT EXECUTED
return rc;
}
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
2547c: e1a00004 mov r0, r4 <== NOT EXECUTED 25480: e1a01005 mov r1, r5 <== NOT EXECUTED 25484: e1a02006 mov r2, r6 <== NOT EXECUTED 25488: e28d3004 add r3, sp, #4 <== NOT EXECUTED 2548c: ebffff19 bl 250f8 <fat_file_lseek> <== NOT EXECUTED
if (rc != RC_OK)
25490: e3500000 cmp r0, #0 <== NOT EXECUTED 25494: 1a000013 bne 254e8 <fat_file_truncate+0xdc> <== NOT EXECUTED
return rc;
rc = fat_free_fat_clusters_chain(mt_entry, cur_cln);
25498: e1a00004 mov r0, r4 <== NOT EXECUTED 2549c: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 254a0: eb0066c1 bl 3efac <fat_free_fat_clusters_chain> <== NOT EXECUTED
if (rc != RC_OK)
254a4: e3500000 cmp r0, #0 <== NOT EXECUTED 254a8: 1a00000e bne 254e8 <fat_file_truncate+0xdc> <== NOT EXECUTED
return rc;
if (cl_start != 0)
254ac: e3560000 cmp r6, #0 <== NOT EXECUTED 254b0: 0a00000c beq 254e8 <fat_file_truncate+0xdc> <== NOT EXECUTED
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
254b4: e1a00004 mov r0, r4 <== NOT EXECUTED 254b8: e59d1000 ldr r1, [sp] <== NOT EXECUTED 254bc: e3e02000 mvn r2, #0 <== NOT EXECUTED 254c0: eb0065b7 bl 3eba4 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
254c4: e3500000 cmp r0, #0 <== NOT EXECUTED 254c8: 1a000006 bne 254e8 <fat_file_truncate+0xdc> <== NOT EXECUTED
return rc;
fat_fd->map.file_cln = cl_start - 1;
fat_fd->map.disk_cln = new_last_cln;
254cc: e59d3000 ldr r3, [sp] <== NOT EXECUTED
if (cl_start != 0)
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
if ( rc != RC_OK )
return rc;
fat_fd->map.file_cln = cl_start - 1;
254d0: e2466001 sub r6, r6, #1 <== NOT EXECUTED
fat_fd->map.disk_cln = new_last_cln;
fat_fd->map.last_cln = new_last_cln;
254d4: e585303c str r3, [r5, #60] ; 0x3c <== NOT EXECUTED
if (cl_start != 0)
{
rc = fat_set_fat_cluster(mt_entry, new_last_cln, FAT_GENFAT_EOC);
if ( rc != RC_OK )
return rc;
fat_fd->map.file_cln = cl_start - 1;
254d8: e5856034 str r6, [r5, #52] ; 0x34 <== NOT EXECUTED
fat_fd->map.disk_cln = new_last_cln;
254dc: e5853038 str r3, [r5, #56] ; 0x38 <== NOT EXECUTED 254e0: ea000000 b 254e8 <fat_file_truncate+0xdc> <== NOT EXECUTED
fat_fd->map.last_cln = new_last_cln;
254e4: e3a00000 mov r0, #0 <== NOT EXECUTED
}
return RC_OK;
}
254e8: e28dd008 add sp, sp, #8 <== NOT EXECUTED
254ec: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if ( new_length >= fat_fd->fat_file_size )
return rc;
assert(fat_fd->fat_file_size);
254f0: e3a01f9b mov r1, #620 ; 0x26c <== NOT EXECUTED 254f4: e2811001 add r1, r1, #1 <== NOT EXECUTED 254f8: e59f0008 ldr r0, [pc, #8] ; 25508 <fat_file_truncate+0xfc> <== NOT EXECUTED 254fc: e59f2008 ldr r2, [pc, #8] ; 2550c <fat_file_truncate+0x100><== NOT EXECUTED 25500: e59f3008 ldr r3, [pc, #8] ; 25510 <fat_file_truncate+0x104><== NOT EXECUTED 25504: eb000d06 bl 28924 <__assert_func> <== NOT EXECUTED
000256f4 <fat_file_write>:
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
256f4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
uint32_t save_ofs;
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
if ( count == 0 )
256f8: e2534000 subs r4, r3, #0 <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
256fc: e1a05000 mov r5, r0 <== NOT EXECUTED
int rc = 0;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
25700: e5906034 ldr r6, [r0, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t start,
uint32_t count,
const uint8_t *buf
)
{
25704: e24dd018 sub sp, sp, #24 <== NOT EXECUTED 25708: e1a08002 mov r8, r2 <== NOT EXECUTED 2570c: e1a07001 mov r7, r1 <== NOT EXECUTED
uint32_t save_ofs;
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
if ( count == 0 )
25710: 01a00004 moveq r0, r4 <== NOT EXECUTED 25714: 0a00005a beq 25884 <fat_file_write+0x190> <== NOT EXECUTED
return cmpltd;
if ( start > fat_fd->fat_file_size )
25718: e5913018 ldr r3, [r1, #24] <== NOT EXECUTED 2571c: e1530002 cmp r3, r2 <== NOT EXECUTED
{
int rc = 0;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
25720: e3a03000 mov r3, #0 <== NOT EXECUTED
uint32_t cl_start = 0;
uint32_t ofs = 0;
uint32_t save_ofs;
uint32_t sec = 0;
uint32_t byte = 0;
uint32_t c = 0;
25724: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
{
int rc = 0;
ssize_t ret = 0;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cmpltd = 0;
uint32_t cur_cln = 0;
25728: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
uint32_t c = 0;
if ( count == 0 )
return cmpltd;
if ( start > fat_fd->fat_file_size )
2572c: 3a000076 bcc 2590c <fat_file_write+0x218> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
if ((count > fat_fd->size_limit) ||
25730: e5913014 ldr r3, [r1, #20] <== NOT EXECUTED 25734: e1540003 cmp r4, r3 <== NOT EXECUTED 25738: 8a000073 bhi 2590c <fat_file_write+0x218> <== NOT EXECUTED 2573c: e0643003 rsb r3, r4, r3 <== NOT EXECUTED 25740: e1520003 cmp r2, r3 <== NOT EXECUTED 25744: 8a000070 bhi 2590c <fat_file_write+0x218> <== NOT EXECUTED
(start > fat_fd->size_limit - count))
rtems_set_errno_and_return_minus_one( EIO );
rc = fat_file_extend(mt_entry, fat_fd, start + count, &c);
25748: e084a002 add sl, r4, r2 <== NOT EXECUTED 2574c: e1a0200a mov r2, sl <== NOT EXECUTED 25750: e28d3010 add r3, sp, #16 <== NOT EXECUTED 25754: ebffff6e bl 25514 <fat_file_extend> <== NOT EXECUTED
if (rc != RC_OK)
25758: e3500000 cmp r0, #0 <== NOT EXECUTED 2575c: 1a000048 bne 25884 <fat_file_write+0x190> <== NOT EXECUTED
/*
* check whether there was enough room on device to locate
* file of 'start + count' bytes
*/
if (c != (start + count))
25760: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 25764: e15a0003 cmp sl, r3 <== NOT EXECUTED
count = c - start;
25768: 10684003 rsbne r4, r8, r3 <== NOT EXECUTED
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2576c: e5973020 ldr r3, [r7, #32] <== NOT EXECUTED 25770: e3530001 cmp r3, #1 <== NOT EXECUTED 25774: 0a000044 beq 2588c <fat_file_write+0x198> <== NOT EXECUTED
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
25778: e5d63008 ldrb r3, [r6, #8] <== NOT EXECUTED 2577c: e1a03338 lsr r3, r8, r3 <== NOT EXECUTED
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
25780: e28db014 add fp, sp, #20 <== NOT EXECUTED
return -1;
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
25784: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
25788: e1a02003 mov r2, r3 <== NOT EXECUTED 2578c: e1a00005 mov r0, r5 <== NOT EXECUTED 25790: e1a01007 mov r1, r7 <== NOT EXECUTED 25794: e1a0300b mov r3, fp <== NOT EXECUTED
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
25798: e1d6a0b6 ldrh sl, [r6, #6] <== NOT EXECUTED
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
2579c: ebfffe55 bl 250f8 <fat_file_lseek> <== NOT EXECUTED
if (rc != RC_OK)
257a0: e3500000 cmp r0, #0 <== NOT EXECUTED 257a4: 1a000036 bne 25884 <fat_file_write+0x190> <== NOT EXECUTED
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
257a8: e24aa001 sub sl, sl, #1 <== NOT EXECUTED
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
257ac: e3540000 cmp r4, #0 <== NOT EXECUTED
return ret;
}
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
257b0: e008a00a and sl, r8, sl <== NOT EXECUTED 257b4: e58da008 str sl, [sp, #8] <== NOT EXECUTED
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
257b8: 01a09000 moveq r9, r0 <== NOT EXECUTED 257bc: 01a08000 moveq r8, r0 <== NOT EXECUTED 257c0: 0a000058 beq 25928 <fat_file_write+0x234> <== NOT EXECUTED
cl_start = start >> fs_info->vol.bpc_log2;
save_ofs = ofs = start & (fs_info->vol.bpc - 1);
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
257c4: e5d69002 ldrb r9, [r6, #2] <== NOT EXECUTED 257c8: e1d620b0 ldrh r2, [r6] <== NOT EXECUTED 257cc: e1a08000 mov r8, r0 <== NOT EXECUTED 257d0: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 257d4: e58d700c str r7, [sp, #12] <== NOT EXECUTED 257d8: e59da03c ldr sl, [sp, #60] ; 0x3c <== NOT EXECUTED 257dc: ea000004 b 257f4 <fat_file_write+0x100> <== NOT EXECUTED
return rc;
while (count > 0)
257e0: e0544007 subs r4, r4, r7 <== NOT EXECUTED
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
cmpltd += c;
257e4: e0888007 add r8, r8, r7 <== NOT EXECUTED
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
257e8: 0a00004c beq 25920 <fat_file_write+0x22c> <== NOT EXECUTED 257ec: e5d69002 ldrb r9, [r6, #2] <== NOT EXECUTED 257f0: e1d620b0 ldrh r2, [r6] <== NOT EXECUTED
{
c = MIN(count, (fs_info->vol.bpc - ofs));
257f4: e1d6c0b6 ldrh ip, [r6, #6] <== NOT EXECUTED
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
257f8: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
257fc: e061c00c rsb ip, r1, ip <== NOT EXECUTED 25800: e15c0004 cmp ip, r4 <== NOT EXECUTED 25804: 21a0c004 movcs ip, r4 <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25808: e3500000 cmp r0, #0 <== NOT EXECUTED
fat_cluster_num_to_sector_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
2580c: e5953034 ldr r3, [r5, #52] ; 0x34 <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
25810: e2400002 sub r0, r0, #2 <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25814: 1a000003 bne 25828 <fat_file_write+0x134> <== NOT EXECUTED 25818: e5d3e00a ldrb lr, [r3, #10] <== NOT EXECUTED 2581c: e31e0003 tst lr, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
25820: 1593701c ldrne r7, [r3, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
25824: 1a000002 bne 25834 <fat_file_write+0x140> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
25828: e593e030 ldr lr, [r3, #48] ; 0x30 <== NOT EXECUTED 2582c: e5d37005 ldrb r7, [r3, #5] <== NOT EXECUTED 25830: e08e7710 add r7, lr, r0, lsl r7 <== NOT EXECUTED
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
25834: e2422001 sub r2, r2, #1 <== NOT EXECUTED 25838: e0022001 and r2, r2, r1 <== NOT EXECUTED 2583c: e08ae008 add lr, sl, r8 <== NOT EXECUTED 25840: e1a0300c mov r3, ip <== NOT EXECUTED 25844: e1a00005 mov r0, r5 <== NOT EXECUTED 25848: e0871931 add r1, r7, r1, lsr r9 <== NOT EXECUTED 2584c: e58de000 str lr, [sp] <== NOT EXECUTED
if (rc != RC_OK)
return rc;
while (count > 0)
{
c = MIN(count, (fs_info->vol.bpc - ofs));
25850: e58dc010 str ip, [sp, #16] <== NOT EXECUTED
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
25854: eb0002ae bl 26314 <_fat_block_write> <== NOT EXECUTED
if ( ret < 0 )
25858: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
2585c: e1a0200b mov r2, fp <== NOT EXECUTED 25860: e1a00005 mov r0, r5 <== NOT EXECUTED
sec = fat_cluster_num_to_sector_num(mt_entry, cur_cln);
sec += (ofs >> fs_info->vol.sec_log2);
byte = ofs & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
25864: ba000026 blt 25904 <fat_file_write+0x210> <== NOT EXECUTED
return -1;
count -= c;
cmpltd += c;
save_cln = cur_cln;
25868: e59d9014 ldr r9, [sp, #20] <== NOT EXECUTED
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
2586c: e1a01009 mov r1, r9 <== NOT EXECUTED
ret = _fat_block_write(mt_entry, sec, byte, c, buf + cmpltd);
if ( ret < 0 )
return -1;
count -= c;
25870: e59d7010 ldr r7, [sp, #16] <== NOT EXECUTED
cmpltd += c;
save_cln = cur_cln;
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
25874: eb00656b bl 3ee28 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
25878: e2501000 subs r1, r0, #0 <== NOT EXECUTED 2587c: 0affffd7 beq 257e0 <fat_file_write+0xec> <== NOT EXECUTED 25880: e1a00001 mov r0, r1 <== NOT EXECUTED
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
}
25884: e28dd018 add sp, sp, #24 <== NOT EXECUTED
25888: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* file of 'start + count' bytes
*/
if (c != (start + count))
count = c - start;
if ((FAT_FD_OF_ROOT_DIR(fat_fd)) &&
2588c: e5973024 ldr r3, [r7, #36] ; 0x24 <== NOT EXECUTED 25890: e3530000 cmp r3, #0 <== NOT EXECUTED 25894: 1affffb7 bne 25778 <fat_file_write+0x84> <== NOT EXECUTED
(fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)))
25898: e5d6300a ldrb r3, [r6, #10] <== NOT EXECUTED 2589c: e3130003 tst r3, #3 <== NOT EXECUTED 258a0: 0affffb4 beq 25778 <fat_file_write+0x84> <== NOT EXECUTED
{
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->cln);
258a4: e597201c ldr r2, [r7, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
258a8: e3520000 cmp r2, #0 <== NOT EXECUTED
fat_cluster_num_to_sector_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
258ac: e5953034 ldr r3, [r5, #52] ; 0x34 <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
258b0: 1a000003 bne 258c4 <fat_file_write+0x1d0> <== NOT EXECUTED 258b4: e5d3100a ldrb r1, [r3, #10] <== NOT EXECUTED 258b8: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
258bc: 1593301c ldrne r3, [r3, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
258c0: 1a000003 bne 258d4 <fat_file_write+0x1e0> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
258c4: e5931030 ldr r1, [r3, #48] ; 0x30 <== NOT EXECUTED 258c8: e5d33005 ldrb r3, [r3, #5] <== NOT EXECUTED 258cc: e2422002 sub r2, r2, #2 <== NOT EXECUTED 258d0: e0813312 add r3, r1, r2, lsl r3 <== NOT EXECUTED
sec += (start >> fs_info->vol.sec_log2);
byte = start & (fs_info->vol.bps - 1);
ret = _fat_block_write(mt_entry, sec, byte, count, buf);
258d4: e1d620b0 ldrh r2, [r6] <== NOT EXECUTED 258d8: e5d61002 ldrb r1, [r6, #2] <== NOT EXECUTED 258dc: e59dc03c ldr ip, [sp, #60] ; 0x3c <== NOT EXECUTED 258e0: e2422001 sub r2, r2, #1 <== NOT EXECUTED 258e4: e0831138 add r1, r3, r8, lsr r1 <== NOT EXECUTED 258e8: e0082002 and r2, r8, r2 <== NOT EXECUTED 258ec: e1a00005 mov r0, r5 <== NOT EXECUTED 258f0: e1a03004 mov r3, r4 <== NOT EXECUTED 258f4: e58dc000 str ip, [sp] <== NOT EXECUTED 258f8: eb000285 bl 26314 <_fat_block_write> <== NOT EXECUTED
if ( ret < 0 )
258fc: e3500000 cmp r0, #0 <== NOT EXECUTED 25900: aaffffdf bge 25884 <fat_file_write+0x190> <== NOT EXECUTED
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
25904: e3e00000 mvn r0, #0 <== NOT EXECUTED 25908: eaffffdd b 25884 <fat_file_write+0x190> <== NOT EXECUTED
if ( start > fat_fd->fat_file_size )
rtems_set_errno_and_return_minus_one( EIO );
if ((count > fat_fd->size_limit) ||
(start > fat_fd->size_limit - count))
rtems_set_errno_and_return_minus_one( EIO );
2590c: eb0075b7 bl 42ff0 <__errno> <== NOT EXECUTED 25910: e3a03005 mov r3, #5 <== NOT EXECUTED 25914: e5803000 str r3, [r0] <== NOT EXECUTED 25918: e3e00000 mvn r0, #0 <== NOT EXECUTED 2591c: eaffffd8 b 25884 <fat_file_write+0x190> <== NOT EXECUTED 25920: e59d700c ldr r7, [sp, #12] <== NOT EXECUTED
rc = fat_file_lseek(mt_entry, fat_fd, cl_start, &cur_cln);
if (rc != RC_OK)
return rc;
while (count > 0)
25924: e1a00008 mov r0, r8 <== NOT EXECUTED
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
25928: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 2592c: e2412001 sub r2, r1, #1 <== NOT EXECUTED 25930: e5d63008 ldrb r3, [r6, #8] <== NOT EXECUTED 25934: e0828008 add r8, r2, r8 <== NOT EXECUTED 25938: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 2593c: e0828338 add r8, r2, r8, lsr r3 <== NOT EXECUTED
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
25940: e5879038 str r9, [r7, #56] ; 0x38 <== NOT EXECUTED
ofs = 0;
}
/* update cache */
/* XXX: check this - I'm not sure :( */
fat_fd->map.file_cln = cl_start +
25944: e5878034 str r8, [r7, #52] ; 0x34 <== NOT EXECUTED
((save_ofs + cmpltd - 1) >> fs_info->vol.bpc_log2);
fat_fd->map.disk_cln = save_cln;
return cmpltd;
25948: eaffffcd b 25884 <fat_file_write+0x190> <== NOT EXECUTED
0003efac <fat_free_fat_clusters_chain>:
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
3efac: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
3efb0: e5905034 ldr r5, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
3efb4: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 3efb8: e5952010 ldr r2, [r5, #16] <== NOT EXECUTED 3efbc: e0013003 and r3, r1, r3 <== NOT EXECUTED
)
{
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
3efc0: e3a07000 mov r7, #0 <== NOT EXECUTED
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
3efc4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
3efc8: e1520003 cmp r2, r3 <== NOT EXECUTED
int
fat_free_fat_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t chain
)
{
3efcc: e1a06000 mov r6, r0 <== NOT EXECUTED 3efd0: e1a09001 mov r9, r1 <== NOT EXECUTED
int rc = RC_OK, rc1 = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
3efd4: e58d7000 str r7, [sp] <== NOT EXECUTED
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
3efd8: 91a08007 movls r8, r7 <== NOT EXECUTED 3efdc: 9a00001d bls 3f058 <fat_free_fat_clusters_chain+0xac> <== NOT EXECUTED 3efe0: e1a04001 mov r4, r1 <== NOT EXECUTED 3efe4: e1a08007 mov r8, r7 <== NOT EXECUTED 3efe8: e1a0a00d mov sl, sp <== NOT EXECUTED 3efec: ea000009 b 3f018 <fat_free_fat_clusters_chain+0x6c> <== NOT EXECUTED
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
3eff0: ebfffeeb bl 3eba4 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
rc1 = rc;
freed_cls_cnt++;
cur_cln = next_cln;
3eff4: e59d4000 ldr r4, [sp] <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
3eff8: e285200c add r2, r5, #12 <== NOT EXECUTED
3effc: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
3f000: e3500000 cmp r0, #0 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
3f004: e0042002 and r2, r4, r2 <== NOT EXECUTED
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
3f008: 11a08000 movne r8, r0 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
3f00c: e1520003 cmp r2, r3 <== NOT EXECUTED
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
if ( rc != RC_OK )
rc1 = rc;
freed_cls_cnt++;
3f010: e2877001 add r7, r7, #1 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = chain;
uint32_t next_cln = 0;
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
3f014: 2a00000f bcs 3f058 <fat_free_fat_clusters_chain+0xac> <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
3f018: e1a01004 mov r1, r4 <== NOT EXECUTED 3f01c: e1a0200d mov r2, sp <== NOT EXECUTED 3f020: e1a00006 mov r0, r6 <== NOT EXECUTED 3f024: ebffff7f bl 3ee28 <fat_get_fat_cluster> <== NOT EXECUTED
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
3f028: e1a01004 mov r1, r4 <== NOT EXECUTED
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
if ( rc != RC_OK )
3f02c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
fat_buf_release(fs_info);
return rc;
}
rc = fat_set_fat_cluster(mt_entry, cur_cln, FAT_GENFAT_FREE);
3f030: e1a02004 mov r2, r4 <== NOT EXECUTED 3f034: e1a00006 mov r0, r6 <== NOT EXECUTED
uint32_t freed_cls_cnt = 0;
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
rc = fat_get_fat_cluster(mt_entry, cur_cln, &next_cln);
if ( rc != RC_OK )
3f038: 0affffec beq 3eff0 <fat_free_fat_clusters_chain+0x44> <== NOT EXECUTED
{
if(fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
3f03c: e5953040 ldr r3, [r5, #64] ; 0x40 <== NOT EXECUTED 3f040: e3730001 cmn r3, #1 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
3f044: 10873003 addne r3, r7, r3 <== NOT EXECUTED 3f048: 15853040 strne r3, [r5, #64] ; 0x40 <== NOT EXECUTED
fat_buf_release(fs_info);
3f04c: e1a00005 mov r0, r5 <== NOT EXECUTED 3f050: ebff9bce bl 25f90 <fat_buf_release> <== NOT EXECUTED
return rc;
3f054: ea000007 b 3f078 <fat_free_fat_clusters_chain+0xcc> <== NOT EXECUTED
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
3f058: e5953040 ldr r3, [r5, #64] ; 0x40 <== NOT EXECUTED 3f05c: e3730001 cmn r3, #1 <== NOT EXECUTED
fs_info->vol.free_cls += freed_cls_cnt;
3f060: 10873003 addne r3, r7, r3 <== NOT EXECUTED
freed_cls_cnt++;
cur_cln = next_cln;
}
fs_info->vol.next_cl = chain;
3f064: e5859044 str r9, [r5, #68] ; 0x44 <== NOT EXECUTED
if (fs_info->vol.free_cls != FAT_UNDEFINED_VALUE)
fs_info->vol.free_cls += freed_cls_cnt;
3f068: 15853040 strne r3, [r5, #64] ; 0x40 <== NOT EXECUTED
fat_buf_release(fs_info);
3f06c: e1a00005 mov r0, r5 <== NOT EXECUTED 3f070: ebff9bc6 bl 25f90 <fat_buf_release> <== NOT EXECUTED 3f074: e1a04008 mov r4, r8 <== NOT EXECUTED
if (rc1 != RC_OK)
return rc1;
return RC_OK;
}
3f078: e1a00004 mov r0, r4 <== NOT EXECUTED
3f07c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3f080: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
00025e64 <fat_free_unique_ino>:
fat_free_unique_ino(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t ino
)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
25e64: e5903034 ldr r3, [r0, #52] ; 0x34 <== NOT EXECUTED
FAT_SET_UNIQ_INO_FREE((ino - fs_info->uino_base), fs_info->uino);
25e68: e5932078 ldr r2, [r3, #120] ; 0x78 <== NOT EXECUTED 25e6c: e593306c ldr r3, [r3, #108] ; 0x6c <== NOT EXECUTED 25e70: e0622001 rsb r2, r2, r1 <== NOT EXECUTED 25e74: e7d301a2 ldrb r0, [r3, r2, lsr #3] <== NOT EXECUTED 25e78: e2021007 and r1, r2, #7 <== NOT EXECUTED 25e7c: e3a0c001 mov ip, #1 <== NOT EXECUTED 25e80: e1c0111c bic r1, r0, ip, lsl r1 <== NOT EXECUTED 25e84: e7c311a2 strb r1, [r3, r2, lsr #3] <== NOT EXECUTED
}
25e88: e12fff1e bx lr <== NOT EXECUTED
0003ee28 <fat_get_fat_cluster>:
fat_get_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t *ret_val
)
{
3ee28: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
rtems_bdbuf_buffer *block0 = NULL;
3ee2c: e3a03000 mov r3, #0 <== NOT EXECUTED
fat_get_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t *ret_val
)
{
3ee30: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
rtems_bdbuf_buffer *block0 = NULL;
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
3ee34: e3510001 cmp r1, #1 <== NOT EXECUTED
fat_get_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t *ret_val
)
{
3ee38: e1a05001 mov r5, r1 <== NOT EXECUTED
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
rtems_bdbuf_buffer *block0 = NULL;
3ee3c: e58d3000 str r3, [sp] <== NOT EXECUTED
fat_get_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t *ret_val
)
{
3ee40: e1a0a002 mov sl, r2 <== NOT EXECUTED
int rc = RC_OK;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
3ee44: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
rtems_bdbuf_buffer *block0 = NULL;
uint32_t sec = 0;
uint32_t ofs = 0;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
3ee48: 9a000021 bls 3eed4 <fat_get_fat_cluster+0xac> <== NOT EXECUTED 3ee4c: e5943034 ldr r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3ee50: e2833001 add r3, r3, #1 <== NOT EXECUTED 3ee54: e1510003 cmp r1, r3 <== NOT EXECUTED 3ee58: 8a00001d bhi 3eed4 <fat_get_fat_cluster+0xac> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
3ee5c: e5d4300a ldrb r3, [r4, #10] <== NOT EXECUTED 3ee60: e3130001 tst r3, #1 <== NOT EXECUTED 3ee64: 1a000020 bne 3eeec <fat_get_fat_cluster+0xc4> <== NOT EXECUTED 3ee68: e3130002 tst r3, #2 <== NOT EXECUTED 3ee6c: 15d48002 ldrbne r8, [r4, #2] <== NOT EXECUTED 3ee70: 1594304c ldrne r3, [r4, #76] ; 0x4c <== NOT EXECUTED 3ee74: 05d48002 ldrbeq r8, [r4, #2] <== NOT EXECUTED 3ee78: 0594304c ldreq r3, [r4, #76] ; 0x4c <== NOT EXECUTED 3ee7c: 11a06081 lslne r6, r1, #1 <== NOT EXECUTED 3ee80: 01a06101 lsleq r6, r1, #2 <== NOT EXECUTED 3ee84: 10838836 addne r8, r3, r6, lsr r8 <== NOT EXECUTED 3ee88: 00838836 addeq r8, r3, r6, lsr r8 <== NOT EXECUTED
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
3ee8c: e1a00004 mov r0, r4 <== NOT EXECUTED 3ee90: e1a01008 mov r1, r8 <== NOT EXECUTED 3ee94: e3a02001 mov r2, #1 <== NOT EXECUTED 3ee98: e1a0300d mov r3, sp <== NOT EXECUTED
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
3ee9c: e1d490b0 ldrh r9, [r4] <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
3eea0: ebff9c95 bl 260fc <fat_buf_access> <== NOT EXECUTED
if (rc != RC_OK)
3eea4: e3500000 cmp r0, #0 <== NOT EXECUTED
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
3eea8: e1a0700d mov r7, sp <== NOT EXECUTED
if (rc != RC_OK)
3eeac: 1a00000c bne 3eee4 <fat_get_fat_cluster+0xbc> <== NOT EXECUTED
return rc;
switch ( fs_info->vol.type )
3eeb0: e5d4200a ldrb r2, [r4, #10] <== NOT EXECUTED
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
3eeb4: e2499001 sub r9, r9, #1 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
3eeb8: e3520002 cmp r2, #2 <== NOT EXECUTED
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
3eebc: e0066009 and r6, r6, r9 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
3eec0: 0a00000e beq 3ef00 <fat_get_fat_cluster+0xd8> <== NOT EXECUTED 3eec4: e3520004 cmp r2, #4 <== NOT EXECUTED 3eec8: 0a000025 beq 3ef64 <fat_get_fat_cluster+0x13c> <== NOT EXECUTED 3eecc: e3520001 cmp r2, #1 <== NOT EXECUTED 3eed0: 0a00000f beq 3ef14 <fat_get_fat_cluster+0xec> <== NOT EXECUTED
*ret_val = *((uint32_t *)(block0->buffer + ofs));
*ret_val = CF_LE_L(*ret_val);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
3eed4: eb001045 bl 42ff0 <__errno> <== NOT EXECUTED 3eed8: e3a03005 mov r3, #5 <== NOT EXECUTED 3eedc: e5803000 str r3, [r0] <== NOT EXECUTED 3eee0: e3e00000 mvn r0, #0 <== NOT EXECUTED
break;
}
return RC_OK;
}
3eee4: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3eee8: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
3eeec: e5d48002 ldrb r8, [r4, #2] <== NOT EXECUTED 3eef0: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED 3eef4: e08160a1 add r6, r1, r1, lsr #1 <== NOT EXECUTED 3eef8: e0838836 add r8, r3, r6, lsr r8 <== NOT EXECUTED 3eefc: eaffffe2 b 3ee8c <fat_get_fat_cluster+0x64> <== NOT EXECUTED
*ret_val = (*ret_val) & FAT_FAT12_MASK;
break;
case FAT_FAT16:
*ret_val = *((uint16_t *)(block0->buffer + ofs));
*ret_val = CF_LE_W(*ret_val);
3ef00: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3ef04: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 3ef08: e19330b6 ldrh r3, [r3, r6] <== NOT EXECUTED 3ef0c: e58a3000 str r3, [sl] <== NOT EXECUTED
break;
3ef10: eafffff3 b 3eee4 <fat_get_fat_cluster+0xbc> <== NOT EXECUTED
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
3ef14: e59d3000 ldr r3, [sp] <== NOT EXECUTED
if ( ofs == (fs_info->vol.bps - 1) )
3ef18: e1d400b0 ldrh r0, [r4] <== NOT EXECUTED
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
3ef1c: e5931020 ldr r1, [r3, #32] <== NOT EXECUTED
if ( ofs == (fs_info->vol.bps - 1) )
3ef20: e2400001 sub r0, r0, #1 <== NOT EXECUTED
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
3ef24: e7d13006 ldrb r3, [r1, r6] <== NOT EXECUTED
if ( ofs == (fs_info->vol.bps - 1) )
3ef28: e1500006 cmp r0, r6 <== NOT EXECUTED
case FAT_FAT12:
/*
* we are enforced in complex computations for FAT12 to escape CPU
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
3ef2c: e58a3000 str r3, [sl] <== NOT EXECUTED
if ( ofs == (fs_info->vol.bps - 1) )
3ef30: 0a000010 beq 3ef78 <fat_get_fat_cluster+0x150> <== NOT EXECUTED
*ret_val |= (*((uint8_t *)(block0->buffer)))<<8;
}
else
{
*ret_val |= (*((uint8_t *)(block0->buffer + ofs + 1)))<<8;
3ef34: e0816006 add r6, r1, r6 <== NOT EXECUTED 3ef38: e5d62001 ldrb r2, [r6, #1] <== NOT EXECUTED 3ef3c: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED 3ef40: e58a3000 str r3, [sl] <== NOT EXECUTED
}
if ( FAT_CLUSTER_IS_ODD(cln) )
3ef44: e2150001 ands r0, r5, #1 <== NOT EXECUTED
*ret_val = (*ret_val) >> FAT12_SHIFT;
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
3ef48: 01a03a03 lsleq r3, r3, #20 <== NOT EXECUTED
{
*ret_val |= (*((uint8_t *)(block0->buffer + ofs + 1)))<<8;
}
if ( FAT_CLUSTER_IS_ODD(cln) )
*ret_val = (*ret_val) >> FAT12_SHIFT;
3ef4c: 11a03223 lsrne r3, r3, #4 <== NOT EXECUTED
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
3ef50: 01a03a23 lsreq r3, r3, #20 <== NOT EXECUTED
{
*ret_val |= (*((uint8_t *)(block0->buffer + ofs + 1)))<<8;
}
if ( FAT_CLUSTER_IS_ODD(cln) )
*ret_val = (*ret_val) >> FAT12_SHIFT;
3ef54: 158a3000 strne r3, [sl] <== NOT EXECUTED 3ef58: 13a00000 movne r0, #0 <== NOT EXECUTED
else
*ret_val = (*ret_val) & FAT_FAT12_MASK;
3ef5c: 058a3000 streq r3, [sl] <== NOT EXECUTED 3ef60: eaffffdf b 3eee4 <fat_get_fat_cluster+0xbc> <== NOT EXECUTED
*ret_val = CF_LE_W(*ret_val);
break;
case FAT_FAT32:
*ret_val = *((uint32_t *)(block0->buffer + ofs));
*ret_val = CF_LE_L(*ret_val);
3ef64: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3ef68: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 3ef6c: e7933006 ldr r3, [r3, r6] <== NOT EXECUTED 3ef70: e58a3000 str r3, [sl] <== NOT EXECUTED
break;
3ef74: eaffffda b 3eee4 <fat_get_fat_cluster+0xbc> <== NOT EXECUTED
* align problems for some architectures
*/
*ret_val = (*((uint8_t *)(block0->buffer + ofs)));
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
3ef78: e1a00004 mov r0, r4 <== NOT EXECUTED 3ef7c: e2881001 add r1, r8, #1 <== NOT EXECUTED 3ef80: e1a0300d mov r3, sp <== NOT EXECUTED 3ef84: ebff9c5c bl 260fc <fat_buf_access> <== NOT EXECUTED
&block0);
if (rc != RC_OK)
3ef88: e3500000 cmp r0, #0 <== NOT EXECUTED 3ef8c: 1affffd4 bne 3eee4 <fat_get_fat_cluster+0xbc> <== NOT EXECUTED
return rc;
*ret_val |= (*((uint8_t *)(block0->buffer)))<<8;
3ef90: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3ef94: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 3ef98: e5d32000 ldrb r2, [r3] <== NOT EXECUTED 3ef9c: e59a3000 ldr r3, [sl] <== NOT EXECUTED 3efa0: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED 3efa4: e58a3000 str r3, [sl] <== NOT EXECUTED 3efa8: eaffffe5 b 3ef44 <fat_get_fat_cluster+0x11c> <== NOT EXECUTED
00025ea4 <fat_get_unique_ino>:
* 0 means FAILED !!!
*
*/
uint32_t
fat_get_unique_ino(rtems_filesystem_mount_table_entry_t *mt_entry)
{
25ea4: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
register fat_fs_info_t *fs_info = mt_entry->fs_info;
25ea8: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED 25eac: e5941074 ldr r1, [r4, #116] ; 0x74 <== NOT EXECUTED
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
return (fs_info->uino_base + fs_info->index);
25eb0: e3a05000 mov r5, #0 <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
25eb4: e3510000 cmp r1, #0 <== NOT EXECUTED 25eb8: e1a02001 mov r2, r1 <== NOT EXECUTED 25ebc: 0a000019 beq 25f28 <fat_get_unique_ino+0x84> <== NOT EXECUTED
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
25ec0: e284006c add r0, r4, #108 ; 0x6c <== NOT EXECUTED
25ec4: e8900009 ldm r0, {r0, r3} <== NOT EXECUTED
25ec8: e7d061a3 ldrb r6, [r0, r3, lsr #3] <== NOT EXECUTED
25ecc: e203c007 and ip, r3, #7 <== NOT EXECUTED
25ed0: e1a02c56 asr r2, r6, ip <== NOT EXECUTED
25ed4: e3120001 tst r2, #1 <== NOT EXECUTED
25ed8: e08071a3 add r7, r0, r3, lsr #3 <== NOT EXECUTED
25edc: 0a00001b beq 25f50 <fat_get_unique_ino+0xac> <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
return (fs_info->uino_base + fs_info->index);
25ee0: e3a02000 mov r2, #0 <== NOT EXECUTED 25ee4: ea000006 b 25f04 <fat_get_unique_ino+0x60> <== NOT EXECUTED
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
25ee8: e5943070 ldr r3, [r4, #112] ; 0x70 <== NOT EXECUTED 25eec: e7d061a3 ldrb r6, [r0, r3, lsr #3] <== NOT EXECUTED 25ef0: e203c007 and ip, r3, #7 <== NOT EXECUTED 25ef4: e1a07c56 asr r7, r6, ip <== NOT EXECUTED 25ef8: e3170001 tst r7, #1 <== NOT EXECUTED 25efc: e08071a3 add r7, r0, r3, lsr #3 <== NOT EXECUTED 25f00: 0a000012 beq 25f50 <fat_get_unique_ino+0xac> <== NOT EXECUTED
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
return (fs_info->uino_base + fs_info->index);
}
fs_info->index++;
25f04: e2833001 add r3, r3, #1 <== NOT EXECUTED
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
25f08: e1510003 cmp r1, r3 <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
25f0c: e2822001 add r2, r2, #1 <== NOT EXECUTED
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
return (fs_info->uino_base + fs_info->index);
}
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
25f10: 81a0c003 movhi ip, r3 <== NOT EXECUTED 25f14: 91a0c005 movls ip, r5 <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
25f18: e1520001 cmp r2, r1 <== NOT EXECUTED
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
return (fs_info->uino_base + fs_info->index);
}
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
25f1c: e584c070 str ip, [r4, #112] ; 0x70 <== NOT EXECUTED
uint32_t j = 0;
bool resrc_unsuff = false;
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
25f20: 3afffff0 bcc 25ee8 <fat_get_unique_ino+0x44> <== NOT EXECUTED 25f24: e1a02001 mov r2, r1 <== NOT EXECUTED
fs_info->index++;
if (fs_info->index >= fs_info->uino_pool_size)
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
25f28: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED 25f2c: e26336ff rsb r3, r3, #267386880 ; 0xff00000 <== NOT EXECUTED 25f30: e2833aff add r3, r3, #1044480 ; 0xff000 <== NOT EXECUTED 25f34: e2833eff add r3, r3, #4080 ; 0xff0 <== NOT EXECUTED 25f38: e1a01082 lsl r1, r2, #1 <== NOT EXECUTED 25f3c: e283300f add r3, r3, #15 <== NOT EXECUTED 25f40: e1510003 cmp r1, r3 <== NOT EXECUTED 25f44: 3a000008 bcc 25f6c <fat_get_unique_ino+0xc8> <== NOT EXECUTED
while (!resrc_unsuff)
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
25f48: e3a00000 mov r0, #0 <== NOT EXECUTED
}
else
resrc_unsuff = true;
}
return 0;
}
25f4c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
{
for (j = 0; j < fs_info->uino_pool_size; j++)
{
if (!FAT_UNIQ_INO_IS_BUSY(fs_info->index, fs_info->uino))
{
FAT_SET_UNIQ_INO_BUSY(fs_info->index, fs_info->uino);
25f50: e3a03001 mov r3, #1 <== NOT EXECUTED 25f54: e186cc13 orr ip, r6, r3, lsl ip <== NOT EXECUTED 25f58: e5c7c000 strb ip, [r7] <== NOT EXECUTED
return (fs_info->uino_base + fs_info->index);
25f5c: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED
25f60: e5940070 ldr r0, [r4, #112] ; 0x70 <== NOT EXECUTED
25f64: e0800003 add r0, r0, r3 <== NOT EXECUTED
25f68: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
fs_info->index = 0;
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
{
fs_info->uino_pool_size <<= 1;
25f6c: e5841074 str r1, [r4, #116] ; 0x74 <== NOT EXECUTED
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
25f70: e594006c ldr r0, [r4, #108] ; 0x6c <== NOT EXECUTED 25f74: ebff8cd1 bl 92c0 <realloc> <== NOT EXECUTED
if (fs_info->uino != NULL)
25f78: e3500000 cmp r0, #0 <== NOT EXECUTED
}
if ((fs_info->uino_pool_size << 1) < (0x0FFFFFFF - fs_info->uino_base))
{
fs_info->uino_pool_size <<= 1;
fs_info->uino = realloc(fs_info->uino, fs_info->uino_pool_size);
25f7c: e584006c str r0, [r4, #108] ; 0x6c <== NOT EXECUTED
if (fs_info->uino != NULL)
25f80: 0afffff0 beq 25f48 <fat_get_unique_ino+0xa4> <== NOT EXECUTED
fs_info->index = fs_info->uino_pool_size;
25f84: e5941074 ldr r1, [r4, #116] ; 0x74 <== NOT EXECUTED 25f88: e5841070 str r1, [r4, #112] ; 0x70 <== NOT EXECUTED 25f8c: eaffffc8 b 25eb4 <fat_get_unique_ino+0x10> <== NOT EXECUTED
00026598 <fat_init_clusters_chain>:
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
26598: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
int rc = RC_OK;
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
2659c: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
265a0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
int rc = RC_OK;
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = start_cln;
265a4: e58d1000 str r1, [sp] <== NOT EXECUTED
int
fat_init_clusters_chain(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t start_cln
)
{
265a8: e1a05000 mov r5, r0 <== NOT EXECUTED
ssize_t ret = 0;
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = start_cln;
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
265ac: e3a01001 mov r1, #1 <== NOT EXECUTED 265b0: e1d400b6 ldrh r0, [r4, #6] <== NOT EXECUTED 265b4: ebff8469 bl 7760 <calloc> <== NOT EXECUTED
if ( buf == NULL )
265b8: e2506000 subs r6, r0, #0 <== NOT EXECUTED
{
free(buf);
return -1;
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
265bc: 11a0700d movne r7, sp <== NOT EXECUTED
register fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cur_cln = start_cln;
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
if ( buf == NULL )
265c0: 0a00001b beq 26634 <fat_init_clusters_chain+0x9c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
265c4: e59d3000 ldr r3, [sp] <== NOT EXECUTED 265c8: e594e00c ldr lr, [r4, #12] <== NOT EXECUTED 265cc: e594c010 ldr ip, [r4, #16] <== NOT EXECUTED
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
265d0: e1a01003 mov r1, r3 <== NOT EXECUTED
buf = calloc(fs_info->vol.bpc, sizeof(char));
if ( buf == NULL )
rtems_set_errno_and_return_minus_one( EIO );
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
265d4: e003300e and r3, r3, lr <== NOT EXECUTED 265d8: e153000c cmp r3, ip <== NOT EXECUTED
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
265dc: e1a02006 mov r2, r6 <== NOT EXECUTED 265e0: e1a00005 mov r0, r5 <== NOT EXECUTED
buf = calloc(fs_info->vol.bpc, sizeof(char));
if ( buf == NULL )
rtems_set_errno_and_return_minus_one( EIO );
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
265e4: 2a00000e bcs 26624 <fat_init_clusters_chain+0x8c> <== NOT EXECUTED
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
265e8: ebffffd4 bl 26540 <fat_cluster_write> <== NOT EXECUTED 265ec: e1a08000 mov r8, r0 <== NOT EXECUTED
if ( ret == -1 )
265f0: e3780001 cmn r8, #1 <== NOT EXECUTED
{
free(buf);
return -1;
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
265f4: e1a0200d mov r2, sp <== NOT EXECUTED 265f8: e1a00005 mov r0, r5 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
while ((cur_cln & fs_info->vol.mask) < fs_info->vol.eoc_val)
{
ret = fat_cluster_write(mt_entry, cur_cln, buf);
if ( ret == -1 )
265fc: 0a000003 beq 26610 <fat_init_clusters_chain+0x78> <== NOT EXECUTED
{
free(buf);
return -1;
}
rc = fat_get_fat_cluster(mt_entry, cur_cln, &cur_cln);
26600: e59d1000 ldr r1, [sp] <== NOT EXECUTED 26604: eb006207 bl 3ee28 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
26608: e2508000 subs r8, r0, #0 <== NOT EXECUTED 2660c: 0affffec beq 265c4 <fat_init_clusters_chain+0x2c> <== NOT EXECUTED
{
free(buf);
26610: e1a00006 mov r0, r6 <== NOT EXECUTED 26614: ebff85d5 bl 7d70 <free> <== NOT EXECUTED
}
}
free(buf);
return rc;
}
26618: e1a00008 mov r0, r8 <== NOT EXECUTED
2661c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
26620: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
free(buf);
return rc;
}
}
free(buf);
26624: e1a00006 mov r0, r6 <== NOT EXECUTED 26628: ebff85d0 bl 7d70 <free> <== NOT EXECUTED 2662c: e3a08000 mov r8, #0 <== NOT EXECUTED
return rc;
26630: eafffff8 b 26618 <fat_init_clusters_chain+0x80> <== NOT EXECUTED
uint32_t cur_cln = start_cln;
char *buf;
buf = calloc(fs_info->vol.bpc, sizeof(char));
if ( buf == NULL )
rtems_set_errno_and_return_minus_one( EIO );
26634: eb00726d bl 42ff0 <__errno> <== NOT EXECUTED 26638: e3a03005 mov r3, #5 <== NOT EXECUTED 2663c: e5803000 str r3, [r0] <== NOT EXECUTED 26640: e3e08000 mvn r8, #0 <== NOT EXECUTED 26644: eafffff3 b 26618 <fat_init_clusters_chain+0x80> <== NOT EXECUTED
000266e4 <fat_init_volume_info>:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
{
266e4: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
266e8: e24dd0b8 sub sp, sp, #184 ; 0xb8 <== NOT EXECUTED
266ec: e1a05000 mov r5, r0 <== NOT EXECUTED
char boot_rec[FAT_MAX_BPB_SIZE];
char fs_info_sector[FAT_USEFUL_INFO_SIZE];
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
266f0: e3a06000 mov r6, #0 <== NOT EXECUTED
rc = stat(mt_entry->dev, &stat_buf);
266f4: e5900070 ldr r0, [r0, #112] ; 0x70 <== NOT EXECUTED 266f8: e28d1060 add r1, sp, #96 ; 0x60 <== NOT EXECUTED
char boot_rec[FAT_MAX_BPB_SIZE];
char fs_info_sector[FAT_USEFUL_INFO_SIZE];
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
266fc: e58d60b4 str r6, [sp, #180] ; 0xb4 <== NOT EXECUTED
int
fat_init_volume_info(rtems_filesystem_mount_table_entry_t *mt_entry)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
26700: e5954034 ldr r4, [r5, #52] ; 0x34 <== NOT EXECUTED
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
rc = stat(mt_entry->dev, &stat_buf);
26704: ebff8bcb bl 9638 <stat> <== NOT EXECUTED
if (rc == -1)
26708: e3700001 cmn r0, #1 <== NOT EXECUTED
ssize_t ret = 0;
struct stat stat_buf;
int i = 0;
rtems_bdbuf_buffer *block = NULL;
rc = stat(mt_entry->dev, &stat_buf);
2670c: e1a07000 mov r7, r0 <== NOT EXECUTED
if (rc == -1)
26710: 0a0000e9 beq 26abc <fat_init_volume_info+0x3d8> <== NOT EXECUTED
return rc;
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
26714: e59d306c ldr r3, [sp, #108] ; 0x6c <== NOT EXECUTED 26718: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED 2671c: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED 26720: 1a000151 bne 26c6c <fat_init_volume_info+0x588> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOTTY);
/* check that device is registred as block device and lock it */
vol->dd = rtems_disk_obtain(stat_buf.st_rdev);
26724: e28d1078 add r1, sp, #120 ; 0x78 <== NOT EXECUTED
26728: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
2672c: ebff802a bl 67dc <rtems_disk_obtain> <== NOT EXECUTED
if (vol->dd == NULL)
26730: e3500000 cmp r0, #0 <== NOT EXECUTED
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
rtems_set_errno_and_return_minus_one(ENOTTY);
/* check that device is registred as block device and lock it */
vol->dd = rtems_disk_obtain(stat_buf.st_rdev);
26734: e584005c str r0, [r4, #92] ; 0x5c <== NOT EXECUTED
if (vol->dd == NULL)
26738: 0a000168 beq 26ce0 <fat_init_volume_info+0x5fc> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
vol->dev = stat_buf.st_rdev;
2673c: e28d1078 add r1, sp, #120 ; 0x78 <== NOT EXECUTED
26740: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dev, 0, &block);
26744: e1a02006 mov r2, r6 <== NOT EXECUTED
/* check that device is registred as block device and lock it */
vol->dd = rtems_disk_obtain(stat_buf.st_rdev);
if (vol->dd == NULL)
rtems_set_errno_and_return_minus_one(EIO);
vol->dev = stat_buf.st_rdev;
26748: e5840054 str r0, [r4, #84] ; 0x54 <== NOT EXECUTED 2674c: e5841058 str r1, [r4, #88] ; 0x58 <== NOT EXECUTED
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dev, 0, &block);
26750: e28d30b4 add r3, sp, #180 ; 0xb4 <== NOT EXECUTED 26754: ebff7be7 bl 56f8 <rtems_bdbuf_read> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
26758: e3500000 cmp r0, #0 <== NOT EXECUTED 2675c: 1a00015d bne 26cd8 <fat_init_volume_info+0x5f4> <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EIO);
}
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
26760: e59d30b4 ldr r3, [sp, #180] ; 0xb4 <== NOT EXECUTED 26764: e3a0205a mov r2, #90 ; 0x5a <== NOT EXECUTED 26768: e5931020 ldr r1, [r3, #32] <== NOT EXECUTED 2676c: e28d0004 add r0, sp, #4 <== NOT EXECUTED 26770: eb007ece bl 462b0 <memcpy> <== NOT EXECUTED
sc = rtems_bdbuf_release( block);
26774: e59d00b4 ldr r0, [sp, #180] ; 0xb4 <== NOT EXECUTED 26778: ebff774d bl 44b4 <rtems_bdbuf_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2677c: e3500000 cmp r0, #0 <== NOT EXECUTED 26780: 1a00015b bne 26cf4 <fat_init_volume_info+0x610> <== NOT EXECUTED
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EIO );
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
26784: e5dd2010 ldrb r2, [sp, #16] <== NOT EXECUTED 26788: e5dd300f ldrb r3, [sp, #15] <== NOT EXECUTED 2678c: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED 26790: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED 26794: e1a02823 lsr r2, r3, #16 <== NOT EXECUTED
if ( (vol->bps != 512) &&
26798: e3520b01 cmp r2, #1024 ; 0x400 <== NOT EXECUTED 2679c: 13520c02 cmpne r2, #512 ; 0x200 <== NOT EXECUTED 267a0: 03a01000 moveq r1, #0 <== NOT EXECUTED 267a4: 13a01001 movne r1, #1 <== NOT EXECUTED
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EIO );
}
/* Evaluate boot record */
vol->bps = FAT_GET_BR_BYTES_PER_SECTOR(boot_rec);
267a8: e1c420b0 strh r2, [r4] <== NOT EXECUTED
if ( (vol->bps != 512) &&
267ac: 0a0000c5 beq 26ac8 <fat_init_volume_info+0x3e4> <== NOT EXECUTED 267b0: e3520b02 cmp r2, #2048 ; 0x800 <== NOT EXECUTED 267b4: 0a000001 beq 267c0 <fat_init_volume_info+0xdc> <== NOT EXECUTED 267b8: e3520a01 cmp r2, #4096 ; 0x1000 <== NOT EXECUTED 267bc: 1a000131 bne 26c88 <fat_init_volume_info+0x5a4> <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
267c0: e3a03000 mov r3, #0 <== NOT EXECUTED 267c4: e5c43003 strb r3, [r4, #3] <== NOT EXECUTED 267c8: e1a034a2 lsr r3, r2, #9 <== NOT EXECUTED 267cc: e5d42003 ldrb r2, [r4, #3] <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
267d0: e1a030c3 asr r3, r3, #1 <== NOT EXECUTED 267d4: e2822001 add r2, r2, #1 <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
267d8: e3130001 tst r3, #1 <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
267dc: e20220ff and r2, r2, #255 ; 0xff <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
267e0: 0afffffa beq 267d0 <fat_init_volume_info+0xec> <== NOT EXECUTED 267e4: e5c42003 strb r2, [r4, #3] <== NOT EXECUTED
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
267e8: e1d410b0 ldrh r1, [r4] <== NOT EXECUTED 267ec: e3a03000 mov r3, #0 <== NOT EXECUTED 267f0: e3110001 tst r1, #1 <== NOT EXECUTED 267f4: e5c43002 strb r3, [r4, #2] <== NOT EXECUTED 267f8: e1a03001 mov r3, r1 <== NOT EXECUTED 267fc: 1a000008 bne 26824 <fat_init_volume_info+0x140> <== NOT EXECUTED 26800: e3a02001 mov r2, #1 <== NOT EXECUTED 26804: ea000000 b 2680c <fat_init_volume_info+0x128> <== NOT EXECUTED 26808: e1a02000 mov r2, r0 <== NOT EXECUTED
i >>= 1, vol->sec_log2++);
2680c: e1a030c3 asr r3, r3, #1 <== NOT EXECUTED 26810: e2820001 add r0, r2, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
26814: e3130001 tst r3, #1 <== NOT EXECUTED
i >>= 1, vol->sec_log2++);
26818: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
2681c: 0afffff9 beq 26808 <fat_init_volume_info+0x124> <== NOT EXECUTED 26820: e5c42002 strb r2, [r4, #2] <== NOT EXECUTED
i >>= 1, vol->sec_log2++);
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
26824: e5dd3011 ldrb r3, [sp, #17] <== NOT EXECUTED
/*
* "sectors per cluster" of zero is invalid
* (and would hang the following loop)
*/
if (vol->spc == 0)
26828: e3530000 cmp r3, #0 <== NOT EXECUTED
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
i >>= 1, vol->sec_mul++);
for (vol->sec_log2 = 0, i = vol->bps; (i & 1) == 0;
i >>= 1, vol->sec_log2++);
vol->spc = FAT_GET_BR_SECTORS_PER_CLUSTER(boot_rec);
2682c: e5c43004 strb r3, [r4, #4] <== NOT EXECUTED
/*
* "sectors per cluster" of zero is invalid
* (and would hang the following loop)
*/
if (vol->spc == 0)
26830: 0a000114 beq 26c88 <fat_init_volume_info+0x5a4> <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
26834: e3a02000 mov r2, #0 <== NOT EXECUTED 26838: e3130001 tst r3, #1 <== NOT EXECUTED 2683c: e5c42005 strb r2, [r4, #5] <== NOT EXECUTED 26840: 1a000008 bne 26868 <fat_init_volume_info+0x184> <== NOT EXECUTED 26844: e3a02001 mov r2, #1 <== NOT EXECUTED 26848: ea000000 b 26850 <fat_init_volume_info+0x16c> <== NOT EXECUTED 2684c: e1a02000 mov r2, r0 <== NOT EXECUTED
i >>= 1, vol->spc_log2++);
26850: e1a030c3 asr r3, r3, #1 <== NOT EXECUTED 26854: e2820001 add r0, r2, #1 <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
26858: e3130001 tst r3, #1 <== NOT EXECUTED
i >>= 1, vol->spc_log2++);
2685c: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->spc_log2 = 0, i = vol->spc; (i & 1) == 0;
26860: 0afffff9 beq 2684c <fat_init_volume_info+0x168> <== NOT EXECUTED 26864: e5c42005 strb r2, [r4, #5] <== NOT EXECUTED
i >>= 1, vol->spc_log2++);
/*
* "bytes per cluster" value greater than 32K is invalid
*/
if ((vol->bpc = vol->bps << vol->spc_log2) > MS_BYTES_PER_CLUSTER_LIMIT)
26868: e1a03211 lsl r3, r1, r2 <== NOT EXECUTED 2686c: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED 26870: e1a03823 lsr r3, r3, #16 <== NOT EXECUTED 26874: e3530902 cmp r3, #32768 ; 0x8000 <== NOT EXECUTED 26878: e1c430b6 strh r3, [r4, #6] <== NOT EXECUTED 2687c: 8a000101 bhi 26c88 <fat_init_volume_info+0x5a4> <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
26880: e3a02000 mov r2, #0 <== NOT EXECUTED 26884: e3130001 tst r3, #1 <== NOT EXECUTED 26888: e5c42008 strb r2, [r4, #8] <== NOT EXECUTED 2688c: 1a000008 bne 268b4 <fat_init_volume_info+0x1d0> <== NOT EXECUTED 26890: e3a02001 mov r2, #1 <== NOT EXECUTED 26894: ea000000 b 2689c <fat_init_volume_info+0x1b8> <== NOT EXECUTED 26898: e1a02000 mov r2, r0 <== NOT EXECUTED
i >>= 1, vol->bpc_log2++);
2689c: e1a030c3 asr r3, r3, #1 <== NOT EXECUTED 268a0: e2820001 add r0, r2, #1 <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
268a4: e3130001 tst r3, #1 <== NOT EXECUTED
i >>= 1, vol->bpc_log2++);
268a8: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one(EINVAL);
}
for (vol->bpc_log2 = 0, i = vol->bpc; (i & 1) == 0;
268ac: 0afffff9 beq 26898 <fat_init_volume_info+0x1b4> <== NOT EXECUTED 268b0: e5c42008 strb r2, [r4, #8] <== NOT EXECUTED
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
268b4: e5dd6014 ldrb r6, [sp, #20] <== NOT EXECUTED 268b8: e5c46009 strb r6, [r4, #9] <== NOT EXECUTED
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
268bc: e5dd3012 ldrb r3, [sp, #18] <== NOT EXECUTED 268c0: e5dd7013 ldrb r7, [sp, #19] <== NOT EXECUTED 268c4: e1837407 orr r7, r3, r7, lsl #8 <== NOT EXECUTED 268c8: e1c471b4 strh r7, [r4, #20] <== NOT EXECUTED
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
268cc: e5dd2016 ldrb r2, [sp, #22] <== NOT EXECUTED 268d0: e5dd3015 ldrb r3, [sp, #21] <== NOT EXECUTED
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
268d4: e2410001 sub r0, r1, #1 <== NOT EXECUTED
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
268d8: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
268dc: e0800283 add r0, r0, r3, lsl #5 <== NOT EXECUTED
i >>= 1, vol->bpc_log2++);
vol->fats = FAT_GET_BR_FAT_NUM(boot_rec);
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
268e0: e1c432b0 strh r3, [r4, #32] <== NOT EXECUTED
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
268e4: eb00d1c3 bl 5aff8 <__aeabi_idiv> <== NOT EXECUTED
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
268e8: e5d43002 ldrb r3, [r4, #2] <== NOT EXECUTED 268ec: e1a03310 lsl r3, r0, r3 <== NOT EXECUTED
vol->fat_loc = FAT_GET_BR_RESERVED_SECTORS_NUM(boot_rec);
vol->rdir_entrs = FAT_GET_BR_FILES_PER_ROOT_DIR(boot_rec);
/* calculate the count of sectors occupied by the root directory */
vol->rdir_secs = ((vol->rdir_entrs * FAT_DIRENTRY_SIZE) + (vol->bps - 1)) /
268f0: e5840024 str r0, [r4, #36] ; 0x24 <== NOT EXECUTED
vol->bps;
vol->rdir_size = vol->rdir_secs << vol->sec_log2;
268f4: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
268f8: e5dd301a ldrb r3, [sp, #26] <== NOT EXECUTED 268fc: e5dd201b ldrb r2, [sp, #27] <== NOT EXECUTED 26900: e1932402 orrs r2, r3, r2, lsl #8 <== NOT EXECUTED
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
26904: 05dd302a ldrbeq r3, [sp, #42] ; 0x2a <== NOT EXECUTED 26908: 05dd2029 ldrbeq r2, [sp, #41] ; 0x29 <== NOT EXECUTED 2690c: 05dd1028 ldrbeq r1, [sp, #40] ; 0x28 <== NOT EXECUTED 26910: 01a03803 lsleq r3, r3, #16 <== NOT EXECUTED 26914: 01833402 orreq r3, r3, r2, lsl #8 <== NOT EXECUTED 26918: 05dd202b ldrbeq r2, [sp, #43] ; 0x2b <== NOT EXECUTED 2691c: 01833001 orreq r3, r3, r1 <== NOT EXECUTED 26920: 01832c02 orreq r2, r3, r2, lsl #24 <== NOT EXECUTED 26924: e5842018 str r2, [r4, #24] <== NOT EXECUTED
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
26928: e5d4c009 ldrb ip, [r4, #9] <== NOT EXECUTED 2692c: e594e018 ldr lr, [r4, #24] <== NOT EXECUTED 26930: e1d411b4 ldrh r1, [r4, #20] <== NOT EXECUTED
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
26934: e0807007 add r7, r0, r7 <== NOT EXECUTED 26938: e0237296 mla r3, r6, r2, r7 <== NOT EXECUTED
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
2693c: e0221c9e mla r2, lr, ip, r1 <== NOT EXECUTED
if ( (FAT_GET_BR_SECTORS_PER_FAT(boot_rec)) != 0)
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT(boot_rec);
else
vol->fat_length = FAT_GET_BR_SECTORS_PER_FAT32(boot_rec);
vol->data_fsec = vol->fat_loc + vol->fats * vol->fat_length +
26940: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED
vol->rdir_secs;
/* for FAT12/16 root dir starts at(sector) */
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
26944: e584201c str r2, [r4, #28] <== NOT EXECUTED
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
26948: e5dd1018 ldrb r1, [sp, #24] <== NOT EXECUTED 2694c: e5dd2017 ldrb r2, [sp, #23] <== NOT EXECUTED 26950: e1922401 orrs r2, r2, r1, lsl #8 <== NOT EXECUTED
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
26954: 05dd2026 ldrbeq r2, [sp, #38] ; 0x26 <== NOT EXECUTED 26958: 05dd1025 ldrbeq r1, [sp, #37] ; 0x25 <== NOT EXECUTED 2695c: 01a02802 lsleq r2, r2, #16 <== NOT EXECUTED 26960: 05dd0024 ldrbeq r0, [sp, #36] ; 0x24 <== NOT EXECUTED 26964: 01822401 orreq r2, r2, r1, lsl #8 <== NOT EXECUTED 26968: 05dd1027 ldrbeq r1, [sp, #39] ; 0x27 <== NOT EXECUTED 2696c: 01822000 orreq r2, r2, r0 <== NOT EXECUTED 26970: 01822c01 orreq r2, r2, r1, lsl #24 <== NOT EXECUTED
data_secs = vol->tot_secs - vol->data_fsec;
vol->data_cls = data_secs / vol->spc;
26974: e0630002 rsb r0, r3, r2 <== NOT EXECUTED
vol->rdir_loc = vol->fat_loc + vol->fats * vol->fat_length;
if ( (FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec)) != 0)
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM16(boot_rec);
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
26978: e584202c str r2, [r4, #44] ; 0x2c <== NOT EXECUTED
data_secs = vol->tot_secs - vol->data_fsec;
vol->data_cls = data_secs / vol->spc;
2697c: e5d41004 ldrb r1, [r4, #4] <== NOT EXECUTED 26980: eb00d158 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
26984: e3a03eff mov r3, #4080 ; 0xff0 <== NOT EXECUTED 26988: e2833004 add r3, r3, #4 <== NOT EXECUTED 2698c: e1500003 cmp r0, r3 <== NOT EXECUTED
else
vol->tot_secs = FAT_GET_BR_TOTAL_SECTORS_NUM32(boot_rec);
data_secs = vol->tot_secs - vol->data_fsec;
vol->data_cls = data_secs / vol->spc;
26990: e5840034 str r0, [r4, #52] ; 0x34 <== NOT EXECUTED
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
26994: 8a000050 bhi 26adc <fat_init_volume_info+0x3f8> <== NOT EXECUTED
{
vol->type = FAT_FAT12;
vol->mask = FAT_FAT12_MASK;
26998: e3a02eff mov r2, #4080 ; 0xff0 <== NOT EXECUTED
vol->eoc_val = FAT_FAT12_EOC;
2699c: e1a03002 mov r3, r2 <== NOT EXECUTED 269a0: e2833008 add r3, r3, #8 <== NOT EXECUTED
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
{
vol->type = FAT_FAT12;
vol->mask = FAT_FAT12_MASK;
269a4: e282200f add r2, r2, #15 <== NOT EXECUTED
vol->data_cls = data_secs / vol->spc;
/* determine FAT type at least */
if ( vol->data_cls < FAT_FAT12_MAX_CLN)
{
vol->type = FAT_FAT12;
269a8: e3a01001 mov r1, #1 <== NOT EXECUTED 269ac: e5c4100a strb r1, [r4, #10] <== NOT EXECUTED
vol->mask = FAT_FAT12_MASK;
269b0: e584200c str r2, [r4, #12] <== NOT EXECUTED
vol->eoc_val = FAT_FAT12_EOC;
269b4: e5843010 str r3, [r4, #16] <== NOT EXECUTED
}
}
}
else
{
vol->rdir_cl = 0;
269b8: e3a03000 mov r3, #0 <== NOT EXECUTED
vol->mirror = 0;
vol->afat = 0;
vol->free_cls = 0xFFFFFFFF;
269bc: e3e02000 mvn r2, #0 <== NOT EXECUTED
}
else
{
vol->rdir_cl = 0;
vol->mirror = 0;
vol->afat = 0;
269c0: e5c43050 strb r3, [r4, #80] ; 0x50 <== NOT EXECUTED
vol->free_cls = 0xFFFFFFFF;
vol->next_cl = 0xFFFFFFFF;
269c4: e5842044 str r2, [r4, #68] ; 0x44 <== NOT EXECUTED
}
}
}
else
{
vol->rdir_cl = 0;
269c8: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
vol->mirror = 0;
269cc: e5c43048 strb r3, [r4, #72] ; 0x48 <== NOT EXECUTED
vol->afat = 0;
vol->free_cls = 0xFFFFFFFF;
269d0: e5842040 str r2, [r4, #64] ; 0x40 <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
269d4: e5950034 ldr r0, [r5, #52] ; 0x34 <== NOT EXECUTED 269d8: ebfffd6c bl 25f90 <fat_buf_release> <== NOT EXECUTED
vol->next_cl = 0xFFFFFFFF;
}
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
269dc: e5d41050 ldrb r1, [r4, #80] ; 0x50 <== NOT EXECUTED 269e0: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED 269e4: e1d421b4 ldrh r2, [r4, #20] <== NOT EXECUTED 269e8: e0232190 mla r3, r0, r1, r2 <== NOT EXECUTED
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
269ec: e3a00002 mov r0, #2 <== NOT EXECUTED
vol->next_cl = 0xFFFFFFFF;
}
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
269f0: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
269f4: e3a0100c mov r1, #12 <== NOT EXECUTED 269f8: ebff8358 bl 7760 <calloc> <== NOT EXECUTED
if ( fs_info->vhash == NULL )
269fc: e3500000 cmp r0, #0 <== NOT EXECUTED
_fat_block_release(mt_entry);
vol->afat_loc = vol->fat_loc + vol->fat_length * vol->afat;
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
26a00: e1a03000 mov r3, r0 <== NOT EXECUTED 26a04: e5840064 str r0, [r4, #100] ; 0x64 <== NOT EXECUTED
if ( fs_info->vhash == NULL )
26a08: 0a0000d0 beq 26d50 <fat_init_volume_info+0x66c> <== NOT EXECUTED
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->vhash + i);
26a0c: e280200c add r2, r0, #12 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
26a10: e280c004 add ip, r0, #4 <== NOT EXECUTED
the_chain->permanent_null = NULL;
26a14: e3a05000 mov r5, #0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
26a18: e280e010 add lr, r0, #16 <== NOT EXECUTED
the_chain->permanent_null = NULL;
26a1c: e5835004 str r5, [r3, #4] <== NOT EXECUTED
the_chain->last = _Chain_Head(the_chain);
26a20: e5833008 str r3, [r3, #8] <== NOT EXECUTED
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
26a24: e3a00002 mov r0, #2 <== NOT EXECUTED 26a28: e3a0100c mov r1, #12 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
26a2c: e583e00c str lr, [r3, #12] <== NOT EXECUTED 26a30: e583c000 str ip, [r3] <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
26a34: e5822008 str r2, [r2, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
26a38: e5825004 str r5, [r2, #4] <== NOT EXECUTED 26a3c: ebff8347 bl 7760 <calloc> <== NOT EXECUTED
if ( fs_info->rhash == NULL )
26a40: e1500005 cmp r0, r5 <== NOT EXECUTED
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
26a44: e5840068 str r0, [r4, #104] ; 0x68 <== NOT EXECUTED
if ( fs_info->rhash == NULL )
26a48: 0a0000bc beq 26d40 <fat_init_volume_info+0x65c> <== NOT EXECUTED
rtems_disk_release(vol->dd);
free(fs_info->vhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
26a4c: e280300c add r3, r0, #12 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
26a50: e2802004 add r2, r0, #4 <== NOT EXECUTED
26a54: e2801010 add r1, r0, #16 <== NOT EXECUTED
26a58: e580100c str r1, [r0, #12] <== NOT EXECUTED
26a5c: e8800024 stm r0, {r2, r5} <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
26a60: e5800008 str r0, [r0, #8] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
26a64: e5835004 str r5, [r3, #4] <== NOT EXECUTED
the_chain->last = _Chain_Head(the_chain);
26a68: e5833008 str r3, [r3, #8] <== NOT EXECUTED
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
26a6c: e594202c ldr r2, [r4, #44] ; 0x2c <== NOT EXECUTED 26a70: e5d43003 ldrb r3, [r4, #3] <== NOT EXECUTED 26a74: e1a03312 lsl r3, r2, r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
26a78: e3a00c01 mov r0, #256 ; 0x100 <== NOT EXECUTED
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
26a7c: e1a03203 lsl r3, r3, #4 <== NOT EXECUTED 26a80: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
for (i = 0; i < FAT_HASH_SIZE; i++)
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
26a84: e5840074 str r0, [r4, #116] ; 0x74 <== NOT EXECUTED
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
26a88: e5845070 str r5, [r4, #112] ; 0x70 <== NOT EXECUTED
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
26a8c: e3a01001 mov r1, #1 <== NOT EXECUTED 26a90: ebff8332 bl 7760 <calloc> <== NOT EXECUTED
if ( fs_info->uino == NULL )
26a94: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_chain_initialize_empty(fs_info->rhash + i);
fs_info->uino_pool_size = FAT_UINO_POOL_INIT_SIZE;
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
26a98: e584006c str r0, [r4, #108] ; 0x6c <== NOT EXECUTED
if ( fs_info->uino == NULL )
26a9c: 0a00009b beq 26d10 <fat_init_volume_info+0x62c> <== NOT EXECUTED
rtems_disk_release(vol->dd);
free(fs_info->vhash);
free(fs_info->rhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
26aa0: e1d400b0 ldrh r0, [r4] <== NOT EXECUTED 26aa4: e3a01001 mov r1, #1 <== NOT EXECUTED 26aa8: ebff832c bl 7760 <calloc> <== NOT EXECUTED
if (fs_info->sec_buf == NULL)
26aac: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_disk_release(vol->dd);
free(fs_info->vhash);
free(fs_info->rhash);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
26ab0: e5840088 str r0, [r4, #136] ; 0x88 <== NOT EXECUTED
if (fs_info->sec_buf == NULL)
26ab4: 11a07005 movne r7, r5 <== NOT EXECUTED 26ab8: 0a000079 beq 26ca4 <fat_init_volume_info+0x5c0> <== NOT EXECUTED
free(fs_info->uino);
rtems_set_errno_and_return_minus_one( ENOMEM );
}
return RC_OK;
}
26abc: e1a00007 mov r0, r7 <== NOT EXECUTED
26ac0: e28dd0b8 add sp, sp, #184 ; 0xb8 <== NOT EXECUTED
26ac4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
for (vol->sec_mul = 0, i = (vol->bps >> FAT_SECTOR512_BITS); (i & 1) == 0;
26ac8: e1a03ca3 lsr r3, r3, #25 <== NOT EXECUTED 26acc: e3130001 tst r3, #1 <== NOT EXECUTED 26ad0: e5c41003 strb r1, [r4, #3] <== NOT EXECUTED 26ad4: 0affff3c beq 267cc <fat_init_volume_info+0xe8> <== NOT EXECUTED 26ad8: eaffff42 b 267e8 <fat_init_volume_info+0x104> <== NOT EXECUTED
vol->mask = FAT_FAT12_MASK;
vol->eoc_val = FAT_FAT12_EOC;
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
26adc: e3a03cff mov r3, #65280 ; 0xff00 <== NOT EXECUTED 26ae0: e28330f4 add r3, r3, #244 ; 0xf4 <== NOT EXECUTED 26ae4: e1500003 cmp r0, r3 <== NOT EXECUTED 26ae8: 9a000054 bls 26c40 <fat_init_volume_info+0x55c> <== NOT EXECUTED
vol->mask = FAT_FAT16_MASK;
vol->eoc_val = FAT_FAT16_EOC;
}
else
{
vol->type = FAT_FAT32;
26aec: e3a03004 mov r3, #4 <== NOT EXECUTED 26af0: e5c4300a strb r3, [r4, #10] <== NOT EXECUTED
vol->mask = FAT_FAT32_MASK;
26af4: e3e0320f mvn r3, #-268435456 ; 0xf0000000 <== NOT EXECUTED 26af8: e584300c str r3, [r4, #12] <== NOT EXECUTED
vol->eoc_val = FAT_FAT32_EOC;
26afc: e3e0327f mvn r3, #-268435449 ; 0xf0000007 <== NOT EXECUTED 26b00: e5843010 str r3, [r4, #16] <== NOT EXECUTED
}
}
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
26b04: e5dd3032 ldrb r3, [sp, #50] ; 0x32 <== NOT EXECUTED 26b08: e5dd2031 ldrb r2, [sp, #49] ; 0x31 <== NOT EXECUTED 26b0c: e5dd1030 ldrb r1, [sp, #48] ; 0x30 <== NOT EXECUTED 26b10: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED 26b14: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED 26b18: e5dd2033 ldrb r2, [sp, #51] ; 0x33 <== NOT EXECUTED 26b1c: e1833001 orr r3, r3, r1 <== NOT EXECUTED 26b20: e1833c02 orr r3, r3, r2, lsl #24 <== NOT EXECUTED 26b24: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
26b28: e5dd302c ldrb r3, [sp, #44] ; 0x2c <== NOT EXECUTED 26b2c: e2033080 and r3, r3, #128 ; 0x80 <== NOT EXECUTED
if (vol->mirror)
26b30: e3530000 cmp r3, #0 <== NOT EXECUTED
if (vol->type == FAT_FAT32)
{
vol->rdir_cl = FAT_GET_BR_FAT32_ROOT_CLUSTER(boot_rec);
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
26b34: e5c43048 strb r3, [r4, #72] ; 0x48 <== NOT EXECUTED
if (vol->mirror)
26b38: 0a000049 beq 26c64 <fat_init_volume_info+0x580> <== NOT EXECUTED
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
26b3c: e5dd302c ldrb r3, [sp, #44] ; 0x2c <== NOT EXECUTED 26b40: e203300f and r3, r3, #15 <== NOT EXECUTED 26b44: e5c43050 strb r3, [r4, #80] ; 0x50 <== NOT EXECUTED
else
vol->afat = 0;
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
26b48: e5dd1035 ldrb r1, [sp, #53] ; 0x35 <== NOT EXECUTED 26b4c: e5dd3034 ldrb r3, [sp, #52] ; 0x34 <== NOT EXECUTED 26b50: e1831401 orr r1, r3, r1, lsl #8 <== NOT EXECUTED
if( vol->info_sec == 0 )
26b54: e3510000 cmp r1, #0 <== NOT EXECUTED
if (vol->mirror)
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
else
vol->afat = 0;
vol->info_sec = FAT_GET_BR_FAT32_FS_INFO_SECTOR(boot_rec);
26b58: e1c413bc strh r1, [r4, #60] ; 0x3c <== NOT EXECUTED
if( vol->info_sec == 0 )
26b5c: 0a000049 beq 26c88 <fat_init_volume_info+0x5a4> <== NOT EXECUTED
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , 0,
26b60: e28d60a8 add r6, sp, #168 ; 0xa8 <== NOT EXECUTED 26b64: e1a00005 mov r0, r5 <== NOT EXECUTED 26b68: e3a02000 mov r2, #0 <== NOT EXECUTED 26b6c: e3a03004 mov r3, #4 <== NOT EXECUTED 26b70: e58d6000 str r6, [sp] <== NOT EXECUTED 26b74: ebfffeb3 bl 26648 <_fat_block_read> <== NOT EXECUTED
FAT_FSI_LEADSIG_SIZE, fs_info_sector);
if ( ret < 0 )
26b78: e3500000 cmp r0, #0 <== NOT EXECUTED 26b7c: ba00006b blt 26d30 <fat_init_volume_info+0x64c> <== NOT EXECUTED
{
rtems_disk_release(vol->dd);
return -1;
}
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
26b80: e5dd30aa ldrb r3, [sp, #170] ; 0xaa <== NOT EXECUTED 26b84: e5dd20a9 ldrb r2, [sp, #169] ; 0xa9 <== NOT EXECUTED 26b88: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED 26b8c: e5dd10a8 ldrb r1, [sp, #168] ; 0xa8 <== NOT EXECUTED 26b90: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED 26b94: e5dd20ab ldrb r2, [sp, #171] ; 0xab <== NOT EXECUTED 26b98: e1833001 orr r3, r3, r1 <== NOT EXECUTED 26b9c: e1832c02 orr r2, r3, r2, lsl #24 <== NOT EXECUTED 26ba0: e59f31c4 ldr r3, [pc, #452] ; 26d6c <fat_init_volume_info+0x688><== NOT EXECUTED 26ba4: e1520003 cmp r2, r3 <== NOT EXECUTED 26ba8: 1a000034 bne 26c80 <fat_init_volume_info+0x59c> <== NOT EXECUTED
rtems_disk_release(vol->dd);
rtems_set_errno_and_return_minus_one( EINVAL );
}
else
{
ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
26bac: e1d413bc ldrh r1, [r4, #60] ; 0x3c <== NOT EXECUTED 26bb0: e1a00005 mov r0, r5 <== NOT EXECUTED 26bb4: e3a02f79 mov r2, #484 ; 0x1e4 <== NOT EXECUTED 26bb8: e3a0300c mov r3, #12 <== NOT EXECUTED 26bbc: e58d6000 str r6, [sp] <== NOT EXECUTED 26bc0: ebfffea0 bl 26648 <_fat_block_read> <== NOT EXECUTED
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
26bc4: e3500000 cmp r0, #0 <== NOT EXECUTED 26bc8: ba000056 blt 26d28 <fat_init_volume_info+0x644> <== NOT EXECUTED
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
26bcc: e5dd30ae ldrb r3, [sp, #174] ; 0xae <== NOT EXECUTED 26bd0: e5dd20ad ldrb r2, [sp, #173] ; 0xad <== NOT EXECUTED 26bd4: e5dd10ac ldrb r1, [sp, #172] ; 0xac <== NOT EXECUTED 26bd8: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED 26bdc: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED 26be0: e5dd20af ldrb r2, [sp, #175] ; 0xaf <== NOT EXECUTED 26be4: e1833001 orr r3, r3, r1 <== NOT EXECUTED 26be8: e1833c02 orr r3, r3, r2, lsl #24 <== NOT EXECUTED 26bec: e5843040 str r3, [r4, #64] ; 0x40 <== NOT EXECUTED
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
26bf0: e5dd30b2 ldrb r3, [sp, #178] ; 0xb2 <== NOT EXECUTED 26bf4: e5dd20b1 ldrb r2, [sp, #177] ; 0xb1 <== NOT EXECUTED 26bf8: e5dd10b0 ldrb r1, [sp, #176] ; 0xb0 <== NOT EXECUTED 26bfc: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED 26c00: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED 26c04: e5dd20b3 ldrb r2, [sp, #179] ; 0xb3 <== NOT EXECUTED 26c08: e1833001 orr r3, r3, r1 <== NOT EXECUTED 26c0c: e1833c02 orr r3, r3, r2, lsl #24 <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
26c10: e3e01000 mvn r1, #0 <== NOT EXECUTED
rtems_disk_release(vol->dd);
return -1;
}
vol->free_cls = FAT_GET_FSINFO_FREE_CLUSTER_COUNT(fs_info_sector);
vol->next_cl = FAT_GET_FSINFO_NEXT_FREE_CLUSTER(fs_info_sector);
26c14: e5843044 str r3, [r4, #68] ; 0x44 <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
26c18: e1a00005 mov r0, r5 <== NOT EXECUTED 26c1c: e1a02001 mov r2, r1 <== NOT EXECUTED 26c20: ebfffdf2 bl 263f0 <fat_fat32_update_fsinfo_sector> <== NOT EXECUTED
0xFFFFFFFF);
if ( rc != RC_OK )
26c24: e2507000 subs r7, r0, #0 <== NOT EXECUTED 26c28: 0affff69 beq 269d4 <fat_init_volume_info+0x2f0> <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
26c2c: e5950034 ldr r0, [r5, #52] ; 0x34 <== NOT EXECUTED 26c30: ebfffcd6 bl 25f90 <fat_buf_release> <== NOT EXECUTED
rc = fat_fat32_update_fsinfo_sector(mt_entry, 0xFFFFFFFF,
0xFFFFFFFF);
if ( rc != RC_OK )
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
26c34: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED 26c38: ebff7f7b bl 6a2c <rtems_disk_release> <== NOT EXECUTED
return rc;
26c3c: eaffff9e b 26abc <fat_init_volume_info+0x3d8> <== NOT EXECUTED
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
vol->mask = FAT_FAT16_MASK;
26c40: e3a02801 mov r2, #65536 ; 0x10000 <== NOT EXECUTED
vol->eoc_val = FAT_FAT16_EOC;
26c44: e3a03cff mov r3, #65280 ; 0xff00 <== NOT EXECUTED
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
vol->mask = FAT_FAT16_MASK;
26c48: e2422001 sub r2, r2, #1 <== NOT EXECUTED
vol->eoc_val = FAT_FAT16_EOC;
26c4c: e28330f8 add r3, r3, #248 ; 0xf8 <== NOT EXECUTED
}
else
{
if ( vol->data_cls < FAT_FAT16_MAX_CLN)
{
vol->type = FAT_FAT16;
26c50: e3a01002 mov r1, #2 <== NOT EXECUTED 26c54: e5c4100a strb r1, [r4, #10] <== NOT EXECUTED
vol->mask = FAT_FAT16_MASK;
26c58: e584200c str r2, [r4, #12] <== NOT EXECUTED
vol->eoc_val = FAT_FAT16_EOC;
26c5c: e5843010 str r3, [r4, #16] <== NOT EXECUTED 26c60: eaffff54 b 269b8 <fat_init_volume_info+0x2d4> <== NOT EXECUTED
vol->mirror = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_MIRROR;
if (vol->mirror)
vol->afat = FAT_GET_BR_EXT_FLAGS(boot_rec) & FAT_BR_EXT_FLAGS_FAT_NUM;
else
vol->afat = 0;
26c64: e5c43050 strb r3, [r4, #80] ; 0x50 <== NOT EXECUTED 26c68: eaffffb6 b 26b48 <fat_init_volume_info+0x464> <== NOT EXECUTED
if (rc == -1)
return rc;
/* Must be a block device. */
if (!S_ISBLK(stat_buf.st_mode))
rtems_set_errno_and_return_minus_one(ENOTTY);
26c6c: eb0070df bl 42ff0 <__errno> <== NOT EXECUTED 26c70: e3a03019 mov r3, #25 <== NOT EXECUTED 26c74: e5803000 str r3, [r0] <== NOT EXECUTED 26c78: e3e07000 mvn r7, #0 <== NOT EXECUTED 26c7c: eaffff8e b 26abc <fat_init_volume_info+0x3d8> <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
26c80: e5950034 ldr r0, [r5, #52] ; 0x34 <== NOT EXECUTED 26c84: ebfffcc1 bl 25f90 <fat_buf_release> <== NOT EXECUTED
if (FAT_GET_FSINFO_LEAD_SIGNATURE(fs_info_sector) !=
FAT_FSINFO_LEAD_SIGNATURE_VALUE)
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
26c88: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED 26c8c: ebff7f66 bl 6a2c <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
26c90: eb0070d6 bl 42ff0 <__errno> <== NOT EXECUTED 26c94: e3a03016 mov r3, #22 <== NOT EXECUTED 26c98: e5803000 str r3, [r0] <== NOT EXECUTED 26c9c: e3e07000 mvn r7, #0 <== NOT EXECUTED 26ca0: eaffff85 b 26abc <fat_init_volume_info+0x3d8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
}
fs_info->sec_buf = (uint8_t *)calloc(vol->bps, sizeof(uint8_t));
if (fs_info->sec_buf == NULL)
{
rtems_disk_release(vol->dd);
26ca4: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED 26ca8: ebff7f5f bl 6a2c <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
26cac: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED 26cb0: ebff842e bl 7d70 <free> <== NOT EXECUTED
free(fs_info->rhash);
26cb4: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED 26cb8: ebff842c bl 7d70 <free> <== NOT EXECUTED
free(fs_info->uino);
26cbc: e594006c ldr r0, [r4, #108] ; 0x6c <== NOT EXECUTED 26cc0: ebff842a bl 7d70 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
26cc4: eb0070c9 bl 42ff0 <__errno> <== NOT EXECUTED 26cc8: e3a0300c mov r3, #12 <== NOT EXECUTED 26ccc: e5803000 str r3, [r0] <== NOT EXECUTED 26cd0: e3e07000 mvn r7, #0 <== NOT EXECUTED 26cd4: eaffff78 b 26abc <fat_init_volume_info+0x3d8> <== NOT EXECUTED
/* Read boot record */
/* FIXME: Asserts FAT_MAX_BPB_SIZE < bdbuf block size */
sc = rtems_bdbuf_read( vol->dev, 0, &block);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_disk_release(vol->dd);
26cd8: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED 26cdc: ebff7f52 bl 6a2c <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO);
26ce0: eb0070c2 bl 42ff0 <__errno> <== NOT EXECUTED 26ce4: e3a03005 mov r3, #5 <== NOT EXECUTED 26ce8: e5803000 str r3, [r0] <== NOT EXECUTED 26cec: e3e07000 mvn r7, #0 <== NOT EXECUTED 26cf0: eaffff71 b 26abc <fat_init_volume_info+0x3d8> <== NOT EXECUTED
memcpy( boot_rec, block->buffer, FAT_MAX_BPB_SIZE);
sc = rtems_bdbuf_release( block);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_disk_release(vol->dd);
26cf4: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED 26cf8: ebff7f4b bl 6a2c <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
26cfc: eb0070bb bl 42ff0 <__errno> <== NOT EXECUTED 26d00: e3a03005 mov r3, #5 <== NOT EXECUTED 26d04: e5803000 str r3, [r0] <== NOT EXECUTED 26d08: e3e07000 mvn r7, #0 <== NOT EXECUTED 26d0c: eaffff6a b 26abc <fat_init_volume_info+0x3d8> <== NOT EXECUTED
fs_info->uino_base = (vol->tot_secs << vol->sec_mul) << 4;
fs_info->index = 0;
fs_info->uino = (char *)calloc(fs_info->uino_pool_size, sizeof(char));
if ( fs_info->uino == NULL )
{
rtems_disk_release(vol->dd);
26d10: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED 26d14: ebff7f44 bl 6a2c <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
26d18: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED 26d1c: ebff8413 bl 7d70 <free> <== NOT EXECUTED
free(fs_info->rhash);
26d20: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED 26d24: eaffffe5 b 26cc0 <fat_init_volume_info+0x5dc> <== NOT EXECUTED
int
_fat_block_release(
rtems_filesystem_mount_table_entry_t *mt_entry)
{
fat_fs_info_t *fs_info = mt_entry->fs_info;
return fat_buf_release(fs_info);
26d28: e5950034 ldr r0, [r5, #52] ; 0x34 <== NOT EXECUTED 26d2c: ebfffc97 bl 25f90 <fat_buf_release> <== NOT EXECUTED
ret = _fat_block_read(mt_entry, vol->info_sec , FAT_FSI_INFO,
FAT_USEFUL_INFO_SIZE, fs_info_sector);
if ( ret < 0 )
{
_fat_block_release(mt_entry);
rtems_disk_release(vol->dd);
26d30: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED 26d34: ebff7f3c bl 6a2c <rtems_disk_release> <== NOT EXECUTED 26d38: e3e07000 mvn r7, #0 <== NOT EXECUTED
return -1;
26d3c: eaffff5e b 26abc <fat_init_volume_info+0x3d8> <== NOT EXECUTED
rtems_chain_initialize_empty(fs_info->vhash + i);
fs_info->rhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->rhash == NULL )
{
rtems_disk_release(vol->dd);
26d40: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED 26d44: ebff7f38 bl 6a2c <rtems_disk_release> <== NOT EXECUTED
free(fs_info->vhash);
26d48: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED 26d4c: eaffffdb b 26cc0 <fat_init_volume_info+0x5dc> <== NOT EXECUTED
/* set up collection of fat-files fd */
fs_info->vhash = calloc(FAT_HASH_SIZE, sizeof(rtems_chain_control));
if ( fs_info->vhash == NULL )
{
rtems_disk_release(vol->dd);
26d50: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED 26d54: ebff7f34 bl 6a2c <rtems_disk_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOMEM );
26d58: eb0070a4 bl 42ff0 <__errno> <== NOT EXECUTED 26d5c: e3a0300c mov r3, #12 <== NOT EXECUTED 26d60: e5803000 str r3, [r0] <== NOT EXECUTED 26d64: e3e07000 mvn r7, #0 <== NOT EXECUTED 26d68: eaffff53 b 26abc <fat_init_volume_info+0x3d8> <== NOT EXECUTED
00025e8c <fat_ino_is_unique>:
inline bool
fat_ino_is_unique(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t ino
)
{
25e8c: e5903034 ldr r3, [r0, #52] ; 0x34 <== NOT EXECUTED 25e90: e5930078 ldr r0, [r3, #120] ; 0x78 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
return (ino >= fs_info->uino_base);
}
25e94: e1500001 cmp r0, r1 <== NOT EXECUTED 25e98: 83a00000 movhi r0, #0 <== NOT EXECUTED 25e9c: 93a00001 movls r0, #1 <== NOT EXECUTED 25ea0: e12fff1e bx lr <== NOT EXECUTED
0003f084 <fat_scan_fat_for_free_clusters>:
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
3f084: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
3f088: e3a0b000 mov fp, #0 <== NOT EXECUTED
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
3f08c: e24dd010 sub sp, sp, #16 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
3f090: e58db00c str fp, [sp, #12] <== NOT EXECUTED
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
3f094: e1a04000 mov r4, r0 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
3f098: e5900034 ldr r0, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
uint32_t i = 2;
*cls_added = 0;
if (count == 0)
3f09c: e3520000 cmp r2, #0 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
3f0a0: e5907034 ldr r7, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t *cls_added,
uint32_t *last_cl
)
{
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
3f0a4: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
uint32_t next_cln = 0;
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
uint32_t i = 2;
*cls_added = 0;
3f0a8: e583b000 str fp, [r3] <== NOT EXECUTED
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
3f0ac: e1a0a003 mov sl, r3 <== NOT EXECUTED
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
uint32_t i = 2;
*cls_added = 0;
if (count == 0)
3f0b0: e58d2000 str r2, [sp] <== NOT EXECUTED
uint32_t *chain,
uint32_t count,
uint32_t *cls_added,
uint32_t *last_cl
)
{
3f0b4: e58d1008 str r1, [sp, #8] <== NOT EXECUTED
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
uint32_t i = 2;
*cls_added = 0;
if (count == 0)
3f0b8: 01a0b002 moveq fp, r2 <== NOT EXECUTED 3f0bc: 0a00003f beq 3f1c0 <fat_scan_fat_for_free_clusters+0x13c> <== NOT EXECUTED
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
3f0c0: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 3f0c4: e5925044 ldr r5, [r2, #68] ; 0x44 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t cl4find = 2;
uint32_t next_cln = 0;
uint32_t save_cln = 0;
uint32_t data_cls_val = fs_info->vol.data_cls + 2;
3f0c8: e2877002 add r7, r7, #2 <== NOT EXECUTED
*cls_added = 0;
if (count == 0)
return rc;
if (fs_info->vol.next_cl != FAT_UNDEFINED_VALUE)
3f0cc: e3750001 cmn r5, #1 <== NOT EXECUTED 3f0d0: 03a05002 moveq r5, #2 <== NOT EXECUTED
/*
* fs_info->vol.data_cls is exactly the count of data clusters
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
3f0d4: e3570002 cmp r7, #2 <== NOT EXECUTED 3f0d8: 9a00003b bls 3f1cc <fat_scan_fat_for_free_clusters+0x148> <== NOT EXECUTED 3f0dc: e3a06002 mov r6, #2 <== NOT EXECUTED 3f0e0: e28d900c add r9, sp, #12 <== NOT EXECUTED 3f0e4: ea000011 b 3f130 <fat_scan_fat_for_free_clusters+0xac> <== NOT EXECUTED
* by separate 'if' statement because otherwise undo function
* wouldn't work properly
*/
if (*cls_added == 0)
{
*chain = cl4find;
3f0e8: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 3f0ec: e5825000 str r5, [r2] <== NOT EXECUTED
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
3f0f0: e3e02000 mvn r2, #0 <== NOT EXECUTED 3f0f4: ebfffeaa bl 3eba4 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
3f0f8: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3f0fc: 1a00002f bne 3f1c0 <fat_scan_fat_for_free_clusters+0x13c> <== NOT EXECUTED
return rc;
}
}
save_cln = cl4find;
(*cls_added)++;
3f100: e59a3000 ldr r3, [sl] <== NOT EXECUTED
/* have we satisfied request ? */
if (*cls_added == count)
3f104: e59d2000 ldr r2, [sp] <== NOT EXECUTED
return rc;
}
}
save_cln = cl4find;
(*cls_added)++;
3f108: e2833001 add r3, r3, #1 <== NOT EXECUTED
/* have we satisfied request ? */
if (*cls_added == count)
3f10c: e1520003 cmp r2, r3 <== NOT EXECUTED
return rc;
}
}
save_cln = cl4find;
(*cls_added)++;
3f110: e58a3000 str r3, [sl] <== NOT EXECUTED
/* have we satisfied request ? */
if (*cls_added == count)
3f114: 0a000044 beq 3f22c <fat_scan_fat_for_free_clusters+0x1a8> <== NOT EXECUTED
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
fs_info->vol.free_cls -= (*cls_added);
*last_cl = save_cln;
fat_buf_release(fs_info);
return rc;
3f118: e1a0b005 mov fp, r5 <== NOT EXECUTED
}
}
i++;
cl4find++;
3f11c: e2855001 add r5, r5, #1 <== NOT EXECUTED
if (cl4find >= data_cls_val)
3f120: e1570005 cmp r7, r5 <== NOT EXECUTED 3f124: 93a05002 movls r5, #2 <== NOT EXECUTED
/*
* fs_info->vol.data_cls is exactly the count of data clusters
* starting at cluster 2, so the maximum valid cluster number is
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
3f128: e1570006 cmp r7, r6 <== NOT EXECUTED 3f12c: 9a000026 bls 3f1cc <fat_scan_fat_for_free_clusters+0x148> <== NOT EXECUTED
{
rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);
3f130: e1a01005 mov r1, r5 <== NOT EXECUTED 3f134: e1a02009 mov r2, r9 <== NOT EXECUTED 3f138: e1a00004 mov r0, r4 <== NOT EXECUTED 3f13c: ebffff39 bl 3ee28 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
3f140: e3500000 cmp r0, #0 <== NOT EXECUTED
*last_cl = save_cln;
fat_buf_release(fs_info);
return rc;
}
}
i++;
3f144: e2866001 add r6, r6, #1 <== NOT EXECUTED
* (fs_info->vol.data_cls + 1)
*/
while (i < data_cls_val)
{
rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);
if ( rc != RC_OK )
3f148: 1a00002c bne 3f200 <fat_scan_fat_for_free_clusters+0x17c> <== NOT EXECUTED
if (*cls_added != 0)
fat_free_fat_clusters_chain(mt_entry, (*chain));
return rc;
}
if (next_cln == FAT_GENFAT_FREE)
3f14c: e59d800c ldr r8, [sp, #12] <== NOT EXECUTED 3f150: e3580000 cmp r8, #0 <== NOT EXECUTED 3f154: 1afffff0 bne 3f11c <fat_scan_fat_for_free_clusters+0x98> <== NOT EXECUTED
/*
* We are enforced to process allocation of the first free cluster
* by separate 'if' statement because otherwise undo function
* wouldn't work properly
*/
if (*cls_added == 0)
3f158: e59a3000 ldr r3, [sl] <== NOT EXECUTED 3f15c: e3530000 cmp r3, #0 <== NOT EXECUTED
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
3f160: e1a01005 mov r1, r5 <== NOT EXECUTED 3f164: e3e02000 mvn r2, #0 <== NOT EXECUTED
* wouldn't work properly
*/
if (*cls_added == 0)
{
*chain = cl4find;
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
3f168: e1a00004 mov r0, r4 <== NOT EXECUTED
/*
* We are enforced to process allocation of the first free cluster
* by separate 'if' statement because otherwise undo function
* wouldn't work properly
*/
if (*cls_added == 0)
3f16c: 0affffdd beq 3f0e8 <fat_scan_fat_for_free_clusters+0x64> <== NOT EXECUTED
}
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
3f170: e1a00004 mov r0, r4 <== NOT EXECUTED 3f174: ebfffe8a bl 3eba4 <fat_set_fat_cluster> <== NOT EXECUTED
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
return rc;
}
rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
3f178: e1a0100b mov r1, fp <== NOT EXECUTED
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
if ( rc != RC_OK )
3f17c: e250b000 subs fp, r0, #0 <== NOT EXECUTED
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
return rc;
}
rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
3f180: e1a02005 mov r2, r5 <== NOT EXECUTED 3f184: e1a00004 mov r0, r4 <== NOT EXECUTED
}
else
{
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
if ( rc != RC_OK )
3f188: 1a000034 bne 3f260 <fat_scan_fat_for_free_clusters+0x1dc> <== NOT EXECUTED
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
return rc;
}
rc = fat_set_fat_cluster(mt_entry, save_cln, cl4find);
3f18c: ebfffe84 bl 3eba4 <fat_set_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
3f190: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3f194: 0affffd9 beq 3f100 <fat_scan_fat_for_free_clusters+0x7c> <== NOT EXECUTED
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
3f198: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 3f19c: e5901000 ldr r1, [r0] <== NOT EXECUTED 3f1a0: e1a00004 mov r0, r4 <== NOT EXECUTED 3f1a4: ebffff80 bl 3efac <fat_free_fat_clusters_chain> <== NOT EXECUTED
/* trying to save last allocated cluster for future use */
fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_FREE);
3f1a8: e1a00004 mov r0, r4 <== NOT EXECUTED 3f1ac: e1a01005 mov r1, r5 <== NOT EXECUTED 3f1b0: e1a02008 mov r2, r8 <== NOT EXECUTED 3f1b4: ebfffe7a bl 3eba4 <fat_set_fat_cluster> <== NOT EXECUTED
fat_buf_release(fs_info);
3f1b8: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 3f1bc: ebff9b73 bl 25f90 <fat_buf_release> <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
*last_cl = save_cln;
fat_buf_release(fs_info);
return RC_OK;
}
3f1c0: e1a0000b mov r0, fp <== NOT EXECUTED
3f1c4: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3f1c8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
3f1cc: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 3f1d0: e5903040 ldr r3, [r0, #64] ; 0x40 <== NOT EXECUTED
cl4find++;
if (cl4find >= data_cls_val)
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
3f1d4: e580b044 str fp, [r0, #68] ; 0x44 <== NOT EXECUTED
if (fs_info->vol.free_cls != 0xFFFFFFFF)
3f1d8: e3730001 cmn r3, #1 <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
3f1dc: 159a2000 ldrne r2, [sl] <== NOT EXECUTED 3f1e0: 10623003 rsbne r3, r2, r3 <== NOT EXECUTED
*last_cl = save_cln;
3f1e4: e59d2034 ldr r2, [sp, #52] ; 0x34 <== NOT EXECUTED
cl4find = 2;
}
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
fs_info->vol.free_cls -= (*cls_added);
3f1e8: 15803040 strne r3, [r0, #64] ; 0x40 <== NOT EXECUTED
*last_cl = save_cln;
3f1ec: e582b000 str fp, [r2] <== NOT EXECUTED
fat_buf_release(fs_info);
3f1f0: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 3f1f4: ebff9b65 bl 25f90 <fat_buf_release> <== NOT EXECUTED 3f1f8: e3a0b000 mov fp, #0 <== NOT EXECUTED
return RC_OK;
3f1fc: eaffffef b 3f1c0 <fat_scan_fat_for_free_clusters+0x13c> <== NOT EXECUTED
while (i < data_cls_val)
{
rc = fat_get_fat_cluster(mt_entry, cl4find, &next_cln);
if ( rc != RC_OK )
{
if (*cls_added != 0)
3f200: e59a3000 ldr r3, [sl] <== NOT EXECUTED 3f204: e3530000 cmp r3, #0 <== NOT EXECUTED 3f208: e1a08000 mov r8, r0 <== NOT EXECUTED
fat_free_fat_clusters_chain(mt_entry, (*chain));
3f20c: 01a0b008 moveq fp, r8 <== NOT EXECUTED 3f210: 0affffea beq 3f1c0 <fat_scan_fat_for_free_clusters+0x13c> <== NOT EXECUTED 3f214: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3f218: e1a00004 mov r0, r4 <== NOT EXECUTED 3f21c: e5931000 ldr r1, [r3] <== NOT EXECUTED 3f220: ebffff61 bl 3efac <fat_free_fat_clusters_chain> <== NOT EXECUTED 3f224: e1a0b008 mov fp, r8 <== NOT EXECUTED 3f228: eaffffe4 b 3f1c0 <fat_scan_fat_for_free_clusters+0x13c> <== NOT EXECUTED
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
3f22c: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 3f230: e5903040 ldr r3, [r0, #64] ; 0x40 <== NOT EXECUTED
(*cls_added)++;
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
3f234: e5805044 str r5, [r0, #68] ; 0x44 <== NOT EXECUTED
if (fs_info->vol.free_cls != 0xFFFFFFFF)
3f238: e3730001 cmn r3, #1 <== NOT EXECUTED
fs_info->vol.free_cls -= (*cls_added);
3f23c: 159a2000 ldrne r2, [sl] <== NOT EXECUTED 3f240: 10623003 rsbne r3, r2, r3 <== NOT EXECUTED
*last_cl = save_cln;
3f244: e59d2034 ldr r2, [sp, #52] ; 0x34 <== NOT EXECUTED
/* have we satisfied request ? */
if (*cls_added == count)
{
fs_info->vol.next_cl = save_cln;
if (fs_info->vol.free_cls != 0xFFFFFFFF)
fs_info->vol.free_cls -= (*cls_added);
3f248: 15803040 strne r3, [r0, #64] ; 0x40 <== NOT EXECUTED
*last_cl = save_cln;
3f24c: e5825000 str r5, [r2] <== NOT EXECUTED
fat_buf_release(fs_info);
3f250: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 3f254: ebff9b4d bl 25f90 <fat_buf_release> <== NOT EXECUTED 3f258: e3a0b000 mov fp, #0 <== NOT EXECUTED
return rc;
3f25c: eaffffd7 b 3f1c0 <fat_scan_fat_for_free_clusters+0x13c> <== NOT EXECUTED
/* set EOC value to new allocated cluster */
rc = fat_set_fat_cluster(mt_entry, cl4find, FAT_GENFAT_EOC);
if ( rc != RC_OK )
{
/* cleanup activity */
fat_free_fat_clusters_chain(mt_entry, (*chain));
3f260: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3f264: e5931000 ldr r1, [r3] <== NOT EXECUTED 3f268: ebffff4f bl 3efac <fat_free_fat_clusters_chain> <== NOT EXECUTED
return rc;
3f26c: eaffffd3 b 3f1c0 <fat_scan_fat_for_free_clusters+0x13c> <== NOT EXECUTED
0003eba4 <fat_set_fat_cluster>:
fat_set_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t in_val
)
{
3eba4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t sec = 0;
uint32_t ofs = 0;
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
rtems_bdbuf_buffer *block0 = NULL;
3eba8: e3a03000 mov r3, #0 <== NOT EXECUTED
fat_set_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t in_val
)
{
3ebac: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
rtems_bdbuf_buffer *block0 = NULL;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
3ebb0: e3510001 cmp r1, #1 <== NOT EXECUTED
fat_set_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t in_val
)
{
3ebb4: e1a05001 mov r5, r1 <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t sec = 0;
uint32_t ofs = 0;
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
rtems_bdbuf_buffer *block0 = NULL;
3ebb8: e58d3000 str r3, [sp] <== NOT EXECUTED
fat_set_fat_cluster(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
uint32_t in_val
)
{
3ebbc: e1a0b002 mov fp, r2 <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
3ebc0: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
uint16_t fat16_clv = 0;
uint32_t fat32_clv = 0;
rtems_bdbuf_buffer *block0 = NULL;
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
3ebc4: 9a000021 bls 3ec50 <fat_set_fat_cluster+0xac> <== NOT EXECUTED 3ebc8: e5943034 ldr r3, [r4, #52] ; 0x34 <== NOT EXECUTED 3ebcc: e2833001 add r3, r3, #1 <== NOT EXECUTED 3ebd0: e1510003 cmp r1, r3 <== NOT EXECUTED 3ebd4: 8a00001d bhi 3ec50 <fat_set_fat_cluster+0xac> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
3ebd8: e5d4300a ldrb r3, [r4, #10] <== NOT EXECUTED 3ebdc: e3130001 tst r3, #1 <== NOT EXECUTED 3ebe0: 1a000020 bne 3ec68 <fat_set_fat_cluster+0xc4> <== NOT EXECUTED 3ebe4: e3130002 tst r3, #2 <== NOT EXECUTED 3ebe8: 15d4a002 ldrbne sl, [r4, #2] <== NOT EXECUTED 3ebec: 1594304c ldrne r3, [r4, #76] ; 0x4c <== NOT EXECUTED 3ebf0: 05d4a002 ldrbeq sl, [r4, #2] <== NOT EXECUTED 3ebf4: 0594304c ldreq r3, [r4, #76] ; 0x4c <== NOT EXECUTED 3ebf8: 11a06081 lslne r6, r1, #1 <== NOT EXECUTED 3ebfc: 01a06101 lsleq r6, r1, #2 <== NOT EXECUTED 3ec00: 1083aa36 addne sl, r3, r6, lsr sl <== NOT EXECUTED 3ec04: 0083aa36 addeq sl, r3, r6, lsr sl <== NOT EXECUTED
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
3ec08: e1a00004 mov r0, r4 <== NOT EXECUTED 3ec0c: e1a0100a mov r1, sl <== NOT EXECUTED 3ec10: e3a02001 mov r2, #1 <== NOT EXECUTED 3ec14: e1a0300d mov r3, sp <== NOT EXECUTED
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
3ec18: e1d490b0 ldrh r9, [r4] <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
3ec1c: ebff9d36 bl 260fc <fat_buf_access> <== NOT EXECUTED
if (rc != RC_OK)
3ec20: e3500000 cmp r0, #0 <== NOT EXECUTED
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
3ec24: e1a0800d mov r8, sp <== NOT EXECUTED
if (rc != RC_OK)
3ec28: 1a00000c bne 3ec60 <fat_set_fat_cluster+0xbc> <== NOT EXECUTED
return rc;
switch ( fs_info->vol.type )
3ec2c: e5d4700a ldrb r7, [r4, #10] <== NOT EXECUTED
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
3ec30: e2499001 sub r9, r9, #1 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
3ec34: e3570002 cmp r7, #2 <== NOT EXECUTED
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
fs_info->vol.afat_loc;
ofs = FAT_FAT_OFFSET(fs_info->vol.type, cln) & (fs_info->vol.bps - 1);
3ec38: e0066009 and r6, r6, r9 <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec, FAT_OP_TYPE_READ, &block0);
if (rc != RC_OK)
return rc;
switch ( fs_info->vol.type )
3ec3c: 0a00000e beq 3ec7c <fat_set_fat_cluster+0xd8> <== NOT EXECUTED 3ec40: e3570004 cmp r7, #4 <== NOT EXECUTED 3ec44: 0a00002e beq 3ed04 <fat_set_fat_cluster+0x160> <== NOT EXECUTED 3ec48: e3570001 cmp r7, #1 <== NOT EXECUTED 3ec4c: 0a000010 beq 3ec94 <fat_set_fat_cluster+0xf0> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
break;
default:
rtems_set_errno_and_return_minus_one(EIO);
3ec50: eb0010e6 bl 42ff0 <__errno> <== NOT EXECUTED 3ec54: e3a03005 mov r3, #5 <== NOT EXECUTED 3ec58: e5803000 str r3, [r0] <== NOT EXECUTED 3ec5c: e3e00000 mvn r0, #0 <== NOT EXECUTED
break;
}
return RC_OK;
}
3ec60: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3ec64: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/* sanity check */
if ( (cln < 2) || (cln > (fs_info->vol.data_cls + 1)) )
rtems_set_errno_and_return_minus_one(EIO);
sec = (FAT_FAT_OFFSET(fs_info->vol.type, cln) >> fs_info->vol.sec_log2) +
3ec68: e5d4a002 ldrb sl, [r4, #2] <== NOT EXECUTED 3ec6c: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED 3ec70: e08160a1 add r6, r1, r1, lsr #1 <== NOT EXECUTED 3ec74: e083aa36 add sl, r3, r6, lsr sl <== NOT EXECUTED 3ec78: eaffffe2 b 3ec08 <fat_set_fat_cluster+0x64> <== NOT EXECUTED
}
}
break;
case FAT_FAT16:
*((uint16_t *)(block0->buffer + ofs)) =
3ec7c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3ec80: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 3ec84: e183b0b6 strh fp, [r3, r6] <== NOT EXECUTED
}
static inline void
fat_buf_mark_modified(fat_fs_info_t *fs_info)
{
fs_info->c.modified = true;
3ec88: e3a03001 mov r3, #1 <== NOT EXECUTED 3ec8c: e5c43080 strb r3, [r4, #128] ; 0x80 <== NOT EXECUTED 3ec90: eafffff2 b 3ec60 <fat_set_fat_cluster+0xbc> <== NOT EXECUTED
return rc;
switch ( fs_info->vol.type )
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
3ec94: e3150001 tst r5, #1 <== NOT EXECUTED 3ec98: 0a000023 beq 3ed2c <fat_set_fat_cluster+0x188> <== NOT EXECUTED
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
3ec9c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3eca0: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
3eca4: e7d32006 ldrb r2, [r3, r6] <== NOT EXECUTED 3eca8: e202200f and r2, r2, #15 <== NOT EXECUTED 3ecac: e7c32006 strb r2, [r3, r6] <== NOT EXECUTED
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
3ecb0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3ecb4: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
3ecb8: e7d32006 ldrb r2, [r3, r6] <== NOT EXECUTED
switch ( fs_info->vol.type )
{
case FAT_FAT12:
if ( FAT_CLUSTER_IS_ODD(cln) )
{
fat16_clv = ((uint16_t )in_val) << FAT_FAT12_SHIFT;
3ecbc: e1a0ba0b lsl fp, fp, #20 <== NOT EXECUTED
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) & 0x0F;
*((uint8_t *)(block0->buffer + ofs)) =
3ecc0: e182282b orr r2, r2, fp, lsr #16 <== NOT EXECUTED 3ecc4: e7c32006 strb r2, [r3, r6] <== NOT EXECUTED
(*((uint8_t *)(block0->buffer + ofs))) |
(uint8_t )(fat16_clv & 0x00FF);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
3ecc8: e1d430b0 ldrh r3, [r4] <== NOT EXECUTED 3eccc: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3ecd0: e1530006 cmp r3, r6 <== NOT EXECUTED 3ecd4: e5c47080 strb r7, [r4, #128] ; 0x80 <== NOT EXECUTED 3ecd8: 0a00002e beq 3ed98 <fat_set_fat_cluster+0x1f4> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
3ecdc: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3ece0: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 3ece4: e2866001 add r6, r6, #1 <== NOT EXECUTED 3ece8: e7c30006 strb r0, [r3, r6] <== NOT EXECUTED
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) |
3ecec: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3ecf0: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) &= 0x00;
*((uint8_t *)(block0->buffer + ofs + 1)) =
3ecf4: e7d32006 ldrb r2, [r3, r6] <== NOT EXECUTED 3ecf8: e182bc2b orr fp, r2, fp, lsr #24 <== NOT EXECUTED 3ecfc: e7c3b006 strb fp, [r3, r6] <== NOT EXECUTED 3ed00: eaffffd6 b 3ec60 <fat_set_fat_cluster+0xbc> <== NOT EXECUTED
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
*((uint32_t *)(block0->buffer + ofs)) =
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
3ed04: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3ed08: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
*((uint32_t *)(block0->buffer + ofs)) =
3ed0c: e7932006 ldr r2, [r3, r6] <== NOT EXECUTED
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
*((uint32_t *)(block0->buffer + ofs)) =
3ed10: e3cbb20f bic fp, fp, #-268435456 ; 0xf0000000 <== NOT EXECUTED
break;
case FAT_FAT32:
fat32_clv = CT_LE_L((in_val & FAT_FAT32_MASK));
*((uint32_t *)(block0->buffer + ofs)) =
3ed14: e202220f and r2, r2, #-268435456 ; 0xf0000000 <== NOT EXECUTED
(*((uint32_t *)(block0->buffer + ofs))) & (CT_LE_L(0xF0000000));
*((uint32_t *)(block0->buffer + ofs)) =
3ed18: e182b00b orr fp, r2, fp <== NOT EXECUTED 3ed1c: e783b006 str fp, [r3, r6] <== NOT EXECUTED 3ed20: e3a03001 mov r3, #1 <== NOT EXECUTED 3ed24: e5c43080 strb r3, [r4, #128] ; 0x80 <== NOT EXECUTED 3ed28: eaffffcc b 3ec60 <fat_set_fat_cluster+0xbc> <== NOT EXECUTED
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
3ed2c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3ed30: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 3ed34: e7c30006 strb r0, [r3, r6] <== NOT EXECUTED
*((uint8_t *)(block0->buffer + ofs)) =
(*((uint8_t *)(block0->buffer + ofs))) |
3ed38: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3ed3c: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
(uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
3ed40: e1a0ba0b lsl fp, fp, #20 <== NOT EXECUTED
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
*((uint8_t *)(block0->buffer + ofs)) =
3ed44: e7d32006 ldrb r2, [r3, r6] <== NOT EXECUTED
(uint8_t )((fat16_clv & 0xFF00)>>8);
}
}
else
{
fat16_clv = ((uint16_t )in_val) & FAT_FAT12_MASK;
3ed48: e1a0ba2b lsr fp, fp, #20 <== NOT EXECUTED
*((uint8_t *)(block0->buffer + ofs)) &= 0x00;
*((uint8_t *)(block0->buffer + ofs)) =
3ed4c: e182200b orr r2, r2, fp <== NOT EXECUTED 3ed50: e7c32006 strb r2, [r3, r6] <== NOT EXECUTED
(*((uint8_t *)(block0->buffer + ofs))) |
(uint8_t )(fat16_clv & 0x00FF);
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
3ed54: e1d430b0 ldrh r3, [r4] <== NOT EXECUTED 3ed58: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3ed5c: e1530006 cmp r3, r6 <== NOT EXECUTED 3ed60: e5c47080 strb r7, [r4, #128] ; 0x80 <== NOT EXECUTED 3ed64: 0a00001c beq 3eddc <fat_set_fat_cluster+0x238> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
3ed68: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3ed6c: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 3ed70: e2866001 add r6, r6, #1 <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
}
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
3ed74: e7d32006 ldrb r2, [r3, r6] <== NOT EXECUTED 3ed78: e3c2200f bic r2, r2, #15 <== NOT EXECUTED 3ed7c: e7c32006 strb r2, [r3, r6] <== NOT EXECUTED
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
(*((uint8_t *)(block0->buffer + ofs+1))) |
3ed80: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3ed84: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
else
{
*((uint8_t *)(block0->buffer + ofs + 1)) =
(*((uint8_t *)(block0->buffer + ofs + 1))) & 0xF0;
*((uint8_t *)(block0->buffer + ofs+1)) =
3ed88: e7d32006 ldrb r2, [r3, r6] <== NOT EXECUTED 3ed8c: e182b42b orr fp, r2, fp, lsr #8 <== NOT EXECUTED 3ed90: e7c3b006 strb fp, [r3, r6] <== NOT EXECUTED 3ed94: eaffffb1 b 3ec60 <fat_set_fat_cluster+0xbc> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
3ed98: e28a1001 add r1, sl, #1 <== NOT EXECUTED 3ed9c: e1a0300d mov r3, sp <== NOT EXECUTED 3eda0: e1a00004 mov r0, r4 <== NOT EXECUTED 3eda4: e1a02007 mov r2, r7 <== NOT EXECUTED 3eda8: ebff9cd3 bl 260fc <fat_buf_access> <== NOT EXECUTED
&block0);
if (rc != RC_OK)
3edac: e3500000 cmp r0, #0 <== NOT EXECUTED 3edb0: 1affffaa bne 3ec60 <fat_set_fat_cluster+0xbc> <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
3edb4: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3edb8: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 3edbc: e5c30000 strb r0, [r3] <== NOT EXECUTED
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
3edc0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3edc4: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) &= 0x00;
*((uint8_t *)(block0->buffer)) =
3edc8: e5d32000 ldrb r2, [r3] <== NOT EXECUTED 3edcc: e182bc2b orr fp, r2, fp, lsr #24 <== NOT EXECUTED 3edd0: e5c3b000 strb fp, [r3] <== NOT EXECUTED 3edd4: e5c47080 strb r7, [r4, #128] ; 0x80 <== NOT EXECUTED 3edd8: eaffffa0 b 3ec60 <fat_set_fat_cluster+0xbc> <== NOT EXECUTED
fat_buf_mark_modified(fs_info);
if ( ofs == (fs_info->vol.bps - 1) )
{
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
3eddc: e28a1001 add r1, sl, #1 <== NOT EXECUTED 3ede0: e1a0300d mov r3, sp <== NOT EXECUTED 3ede4: e1a00004 mov r0, r4 <== NOT EXECUTED 3ede8: e1a02007 mov r2, r7 <== NOT EXECUTED 3edec: ebff9cc2 bl 260fc <fat_buf_access> <== NOT EXECUTED
&block0);
if (rc != RC_OK)
3edf0: e3500000 cmp r0, #0 <== NOT EXECUTED 3edf4: 1affff99 bne 3ec60 <fat_set_fat_cluster+0xbc> <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
3edf8: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3edfc: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
rc = fat_buf_access(fs_info, sec + 1, FAT_OP_TYPE_READ,
&block0);
if (rc != RC_OK)
return rc;
*((uint8_t *)(block0->buffer)) =
3ee00: e5d32000 ldrb r2, [r3] <== NOT EXECUTED 3ee04: e3c2200f bic r2, r2, #15 <== NOT EXECUTED 3ee08: e5c32000 strb r2, [r3] <== NOT EXECUTED
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) |
3ee0c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3ee10: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
return rc;
*((uint8_t *)(block0->buffer)) =
(*((uint8_t *)(block0->buffer))) & 0xF0;
*((uint8_t *)(block0->buffer)) =
3ee14: e5d32000 ldrb r2, [r3] <== NOT EXECUTED 3ee18: e182b42b orr fp, r2, fp, lsr #8 <== NOT EXECUTED 3ee1c: e5c3b000 strb fp, [r3] <== NOT EXECUTED 3ee20: e5c47080 strb r7, [r4, #128] ; 0x80 <== NOT EXECUTED 3ee24: eaffff8d b 3ec60 <fat_set_fat_cluster+0xbc> <== NOT EXECUTED
00026458 <fat_shutdown_drive>:
* RC_OK on success, or -1 if error occured
* and errno set appropriately
*/
int
fat_shutdown_drive(rtems_filesystem_mount_table_entry_t *mt_entry)
{
26458: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
int rc = RC_OK;
fat_fs_info_t *fs_info = mt_entry->fs_info;
2645c: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
26460: e5d4500a ldrb r5, [r4, #10] <== NOT EXECUTED 26464: e2155004 ands r5, r5, #4 <== NOT EXECUTED 26468: 1a00002e bne 26528 <fat_shutdown_drive+0xd0> <== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
rc = -1;
}
fat_buf_release(fs_info);
2646c: e1a00004 mov r0, r4 <== NOT EXECUTED 26470: ebfffec6 bl 25f90 <fat_buf_release> <== NOT EXECUTED
if (rtems_bdbuf_syncdev(fs_info->vol.dev) != RTEMS_SUCCESSFUL)
26474: e2841054 add r1, r4, #84 ; 0x54 <== NOT EXECUTED
26478: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
2647c: ebff7563 bl 3a10 <rtems_bdbuf_syncdev> <== NOT EXECUTED
26480: e3500000 cmp r0, #0 <== NOT EXECUTED
26484: 13e05000 mvnne r5, #0 <== NOT EXECUTED
26488: e3a08000 mov r8, #0 <== NOT EXECUTED
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
2648c: e5946064 ldr r6, [r4, #100] ; 0x64 <== NOT EXECUTED 26490: e0866008 add r6, r6, r8 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
26494: ea000000 b 2649c <fat_shutdown_drive+0x44> <== NOT EXECUTED
free(node);
26498: ebff8634 bl 7d70 <free> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
2649c: e1a00006 mov r0, r6 <== NOT EXECUTED 264a0: ebff9b0b bl d0d4 <_Chain_Get> <== NOT EXECUTED
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->vhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
264a4: e2507000 subs r7, r0, #0 <== NOT EXECUTED 264a8: 1afffffa bne 26498 <fat_shutdown_drive+0x40> <== NOT EXECUTED 264ac: e288800c add r8, r8, #12 <== NOT EXECUTED
fat_buf_release(fs_info);
if (rtems_bdbuf_syncdev(fs_info->vol.dev) != RTEMS_SUCCESSFUL)
rc = -1;
for (i = 0; i < FAT_HASH_SIZE; i++)
264b0: e3580018 cmp r8, #24 <== NOT EXECUTED 264b4: 1afffff4 bne 2648c <fat_shutdown_drive+0x34> <== NOT EXECUTED
}
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
264b8: e5946068 ldr r6, [r4, #104] ; 0x68 <== NOT EXECUTED 264bc: e0866007 add r6, r6, r7 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
264c0: ea000000 b 264c8 <fat_shutdown_drive+0x70> <== NOT EXECUTED
free(node);
264c4: ebff8629 bl 7d70 <free> <== NOT EXECUTED 264c8: e1a00006 mov r0, r6 <== NOT EXECUTED 264cc: ebff9b00 bl d0d4 <_Chain_Get> <== NOT EXECUTED
for (i = 0; i < FAT_HASH_SIZE; i++)
{
rtems_chain_node *node = NULL;
rtems_chain_control *the_chain = fs_info->rhash + i;
while ( (node = rtems_chain_get(the_chain)) != NULL )
264d0: e3500000 cmp r0, #0 <== NOT EXECUTED 264d4: 1afffffa bne 264c4 <fat_shutdown_drive+0x6c> <== NOT EXECUTED 264d8: e287700c add r7, r7, #12 <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
for (i = 0; i < FAT_HASH_SIZE; i++)
264dc: e3570018 cmp r7, #24 <== NOT EXECUTED 264e0: 1afffff4 bne 264b8 <fat_shutdown_drive+0x60> <== NOT EXECUTED
while ( (node = rtems_chain_get(the_chain)) != NULL )
free(node);
}
free(fs_info->vhash);
264e4: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED 264e8: ebff8620 bl 7d70 <free> <== NOT EXECUTED
free(fs_info->rhash);
264ec: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED 264f0: ebff861e bl 7d70 <free> <== NOT EXECUTED
free(fs_info->uino);
264f4: e594006c ldr r0, [r4, #108] ; 0x6c <== NOT EXECUTED 264f8: ebff861c bl 7d70 <free> <== NOT EXECUTED
free(fs_info->sec_buf);
264fc: e5940088 ldr r0, [r4, #136] ; 0x88 <== NOT EXECUTED 26500: ebff861a bl 7d70 <free> <== NOT EXECUTED
rtems_disk_release(fs_info->vol.dd);
26504: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED 26508: ebff8147 bl 6a2c <rtems_disk_release> <== NOT EXECUTED
if (rc)
2650c: e3550000 cmp r5, #0 <== NOT EXECUTED 26510: 0a000002 beq 26520 <fat_shutdown_drive+0xc8> <== NOT EXECUTED
errno = EIO;
26514: eb0072b5 bl 42ff0 <__errno> <== NOT EXECUTED 26518: e3a03005 mov r3, #5 <== NOT EXECUTED 2651c: e5803000 str r3, [r0] <== NOT EXECUTED
return rc;
}
26520: e1a00005 mov r0, r5 <== NOT EXECUTED
26524: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
fat_fs_info_t *fs_info = mt_entry->fs_info;
int i = 0;
if (fs_info->vol.type & FAT_FAT32)
{
rc = fat_fat32_update_fsinfo_sector(mt_entry, fs_info->vol.free_cls,
26528: e2841040 add r1, r4, #64 ; 0x40 <== NOT EXECUTED
2652c: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
26530: ebffffae bl 263f0 <fat_fat32_update_fsinfo_sector> <== NOT EXECUTED
fs_info->vol.next_cl);
if ( rc != RC_OK )
26534: e2505000 subs r5, r0, #0 <== NOT EXECUTED 26538: 13e05000 mvnne r5, #0 <== NOT EXECUTED 2653c: eaffffca b 2646c <fat_shutdown_drive+0x14> <== NOT EXECUTED
0003f678 <fchdir>:
#include <rtems/seterr.h>
int fchdir(
int fd
)
{
3f678: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
3f67c: e59f3158 ldr r3, [pc, #344] ; 3f7dc <fchdir+0x164> <== NOT EXECUTED 3f680: e5933000 ldr r3, [r3] <== NOT EXECUTED 3f684: e1500003 cmp r0, r3 <== NOT EXECUTED
#include <rtems/seterr.h>
int fchdir(
int fd
)
{
3f688: e24dd02c sub sp, sp, #44 ; 0x2c <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
3f68c: 2a000040 bcs 3f794 <fchdir+0x11c> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
3f690: e59f3148 ldr r3, [pc, #328] ; 3f7e0 <fchdir+0x168> <== NOT EXECUTED 3f694: e5934000 ldr r4, [r3] <== NOT EXECUTED 3f698: e0844300 add r4, r4, r0, lsl #6 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
3f69c: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3f6a0: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 3f6a4: 0a00003a beq 3f794 <fchdir+0x11c> <== NOT EXECUTED
/*
* Verify you can change directory into this node.
*/
if ( !iop->pathinfo.ops ) {
3f6a8: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 3f6ac: e3530000 cmp r3, #0 <== NOT EXECUTED 3f6b0: 0a000044 beq 3f7c8 <fchdir+0x150> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( !iop->pathinfo.ops->node_type_h ) {
3f6b4: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED 3f6b8: e3530000 cmp r3, #0 <== NOT EXECUTED 3f6bc: 0a000041 beq 3f7c8 <fchdir+0x150> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) !=
3f6c0: e2844018 add r4, r4, #24 <== NOT EXECUTED 3f6c4: e1a00004 mov r0, r4 <== NOT EXECUTED 3f6c8: e1a0e00f mov lr, pc <== NOT EXECUTED 3f6cc: e12fff13 bx r3 <== NOT EXECUTED 3f6d0: e3500001 cmp r0, #1 <== NOT EXECUTED 3f6d4: e1a0e000 mov lr, r0 <== NOT EXECUTED 3f6d8: 1a000028 bne 3f780 <fchdir+0x108> <== NOT EXECUTED
* but note the race condition. Threads who
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
3f6dc: e59f6100 ldr r6, [pc, #256] ; 3f7e4 <fchdir+0x16c> <== NOT EXECUTED
3f6e0: e5967000 ldr r7, [r6] <== NOT EXECUTED
3f6e4: e287c004 add ip, r7, #4 <== NOT EXECUTED
3f6e8: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3f6ec: e28d5004 add r5, sp, #4 <== NOT EXECUTED
3f6f0: e1a08005 mov r8, r5 <== NOT EXECUTED
3f6f4: e8a8000f stmia r8!, {r0, r1, r2, r3} <== NOT EXECUTED
3f6f8: e59c3000 ldr r3, [ip] <== NOT EXECUTED
3f6fc: e5883000 str r3, [r8] <== NOT EXECUTED
rtems_filesystem_current = iop->pathinfo;
3f700: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
3f704: e2877004 add r7, r7, #4 <== NOT EXECUTED
3f708: e8a7000f stmia r7!, {r0, r1, r2, r3} <== NOT EXECUTED
3f70c: e5943000 ldr r3, [r4] <== NOT EXECUTED
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
3f710: e3a07000 mov r7, #0 <== NOT EXECUTED 3f714: e28d4018 add r4, sp, #24 <== NOT EXECUTED
* share their rtems_filesystem_current better
* be synchronized!
*/
saved = rtems_filesystem_current;
rtems_filesystem_current = iop->pathinfo;
3f718: e58c3000 str r3, [ip] <== NOT EXECUTED
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
3f71c: e1a0100e mov r1, lr <== NOT EXECUTED 3f720: e1a02007 mov r2, r7 <== NOT EXECUTED 3f724: e59f00bc ldr r0, [pc, #188] ; 3f7e8 <fchdir+0x170> <== NOT EXECUTED 3f728: e1a03004 mov r3, r4 <== NOT EXECUTED 3f72c: e58d7000 str r7, [sp] <== NOT EXECUTED 3f730: ebff216c bl 7ce8 <rtems_filesystem_evaluate_path> <== NOT EXECUTED 3f734: e1500007 cmp r0, r7 <== NOT EXECUTED 3f738: 1a00001a bne 3f7a8 <fchdir+0x130> <== NOT EXECUTED
/* cloning failed; restore original and bail out */
rtems_filesystem_current = saved;
return -1;
}
/* release the old one */
rtems_filesystem_freenode( &saved );
3f73c: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3f740: e3530000 cmp r3, #0 <== NOT EXECUTED 3f744: 0a000004 beq 3f75c <fchdir+0xe4> <== NOT EXECUTED 3f748: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 3f74c: e3530000 cmp r3, #0 <== NOT EXECUTED 3f750: 11a00005 movne r0, r5 <== NOT EXECUTED 3f754: 11a0e00f movne lr, pc <== NOT EXECUTED 3f758: 112fff13 bxne r3 <== NOT EXECUTED
rtems_filesystem_current = loc;
3f75c: e596c000 ldr ip, [r6] <== NOT EXECUTED
3f760: e8b4000f ldm r4!, {r0, r1, r2, r3} <== NOT EXECUTED
3f764: e28cc004 add ip, ip, #4 <== NOT EXECUTED
3f768: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3f76c: e5943000 ldr r3, [r4] <== NOT EXECUTED
3f770: e58c3000 str r3, [ip] <== NOT EXECUTED
3f774: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
3f778: e28dd02c add sp, sp, #44 ; 0x2c <== NOT EXECUTED
3f77c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( (*iop->pathinfo.ops->node_type_h)( &iop->pathinfo ) !=
RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_set_errno_and_return_minus_one( ENOTDIR );
3f780: eb000e1a bl 42ff0 <__errno> <== NOT EXECUTED 3f784: e3a03014 mov r3, #20 <== NOT EXECUTED 3f788: e5803000 str r3, [r0] <== NOT EXECUTED 3f78c: e3e00000 mvn r0, #0 <== NOT EXECUTED 3f790: eafffff8 b 3f778 <fchdir+0x100> <== NOT EXECUTED
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc, saved;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
3f794: eb000e15 bl 42ff0 <__errno> <== NOT EXECUTED 3f798: e3a03009 mov r3, #9 <== NOT EXECUTED 3f79c: e5803000 str r3, [r0] <== NOT EXECUTED 3f7a0: e3e00000 mvn r0, #0 <== NOT EXECUTED 3f7a4: eafffff3 b 3f778 <fchdir+0x100> <== NOT EXECUTED
rtems_filesystem_current = iop->pathinfo;
/* clone the current node */
if (rtems_filesystem_evaluate_path(".", 1, 0, &loc, 0)) {
/* cloning failed; restore original and bail out */
rtems_filesystem_current = saved;
3f7a8: e596c000 ldr ip, [r6] <== NOT EXECUTED
3f7ac: e8b5000f ldm r5!, {r0, r1, r2, r3} <== NOT EXECUTED
3f7b0: e28cc004 add ip, ip, #4 <== NOT EXECUTED
3f7b4: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
3f7b8: e5983000 ldr r3, [r8] <== NOT EXECUTED
3f7bc: e3e00000 mvn r0, #0 <== NOT EXECUTED
3f7c0: e58c3000 str r3, [ip] <== NOT EXECUTED
return -1;
3f7c4: eaffffeb b 3f778 <fchdir+0x100> <== NOT EXECUTED
if ( !iop->pathinfo.ops ) {
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( !iop->pathinfo.ops->node_type_h ) {
rtems_set_errno_and_return_minus_one( ENOTSUP );
3f7c8: eb000e08 bl 42ff0 <__errno> <== NOT EXECUTED 3f7cc: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 3f7d0: e5803000 str r3, [r0] <== NOT EXECUTED 3f7d4: e3e00000 mvn r0, #0 <== NOT EXECUTED 3f7d8: eaffffe6 b 3f778 <fchdir+0x100> <== NOT EXECUTED
00028de4 <fchmod>:
mode_t mode
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
28de4: e59f3070 ldr r3, [pc, #112] ; 28e5c <fchmod+0x78> <== NOT EXECUTED 28de8: e5932000 ldr r2, [r3] <== NOT EXECUTED 28dec: e1500002 cmp r0, r2 <== NOT EXECUTED
int fchmod(
int fd,
mode_t mode
)
{
28df0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
28df4: 2a00000e bcs 28e34 <fchmod+0x50> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
28df8: e59f3060 ldr r3, [pc, #96] ; 28e60 <fchmod+0x7c> <== NOT EXECUTED 28dfc: e5933000 ldr r3, [r3] <== NOT EXECUTED 28e00: e0833300 add r3, r3, r0, lsl #6 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
28e04: e5932014 ldr r2, [r3, #20] <== NOT EXECUTED 28e08: e3120c01 tst r2, #256 ; 0x100 <== NOT EXECUTED 28e0c: 0a000008 beq 28e34 <fchmod+0x50> <== NOT EXECUTED
/*
* Now process the fchmod().
*/
if ( !iop->handlers->fchmod_h )
28e10: e593203c ldr r2, [r3, #60] ; 0x3c <== NOT EXECUTED 28e14: e592201c ldr r2, [r2, #28] <== NOT EXECUTED 28e18: e3520000 cmp r2, #0 <== NOT EXECUTED 28e1c: 0a000009 beq 28e48 <fchmod+0x64> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
return (*iop->pathinfo.handlers->fchmod_h)( &iop->pathinfo, mode );
28e20: e2830018 add r0, r3, #24 <== NOT EXECUTED 28e24: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 28e28: e1a0e00f mov lr, pc <== NOT EXECUTED 28e2c: e593f01c ldr pc, [r3, #28] <== NOT EXECUTED
}
28e30: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
28e34: eb00686d bl 42ff0 <__errno> <== NOT EXECUTED
28e38: e3a03009 mov r3, #9 <== NOT EXECUTED
28e3c: e5803000 str r3, [r0] <== NOT EXECUTED
28e40: e3e00000 mvn r0, #0 <== NOT EXECUTED
28e44: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
/*
* Now process the fchmod().
*/
if ( !iop->handlers->fchmod_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
28e48: eb006868 bl 42ff0 <__errno> <== NOT EXECUTED
28e4c: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
28e50: e5803000 str r3, [r0] <== NOT EXECUTED
28e54: e3e00000 mvn r0, #0 <== NOT EXECUTED
28e58: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00028e64 <fchown>:
gid_t group
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
28e64: e59f3098 ldr r3, [pc, #152] ; 28f04 <fchown+0xa0> <== NOT EXECUTED 28e68: e5933000 ldr r3, [r3] <== NOT EXECUTED
int fchown(
int fd,
uid_t owner,
gid_t group
)
{
28e6c: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 28e70: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
28e74: e1500003 cmp r0, r3 <== NOT EXECUTED
int fchown(
int fd,
uid_t owner,
gid_t group
)
{
28e78: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
28e7c: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED
28e80: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
28e84: 2a00000f bcs 28ec8 <fchown+0x64> <== NOT EXECUTED
iop = rtems_libio_iop( fd );
28e88: e59f3078 ldr r3, [pc, #120] ; 28f08 <fchown+0xa4> <== NOT EXECUTED 28e8c: e5933000 ldr r3, [r3] <== NOT EXECUTED 28e90: e0830300 add r0, r3, r0, lsl #6 <== NOT EXECUTED
rtems_libio_check_is_open(iop);
28e94: e5903014 ldr r3, [r0, #20] <== NOT EXECUTED 28e98: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED 28e9c: 0a000009 beq 28ec8 <fchown+0x64> <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
28ea0: e3130004 tst r3, #4 <== NOT EXECUTED 28ea4: 0a00000c beq 28edc <fchown+0x78> <== NOT EXECUTED
if ( !iop->pathinfo.ops->chown_h )
28ea8: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED 28eac: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED 28eb0: e3530000 cmp r3, #0 <== NOT EXECUTED 28eb4: 0a00000d beq 28ef0 <fchown+0x8c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
return (*iop->pathinfo.ops->chown_h)( &iop->pathinfo, owner, group );
28eb8: e2800018 add r0, r0, #24 <== NOT EXECUTED 28ebc: e1a0e00f mov lr, pc <== NOT EXECUTED 28ec0: e12fff13 bx r3 <== NOT EXECUTED
}
28ec4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
28ec8: eb006848 bl 42ff0 <__errno> <== NOT EXECUTED
28ecc: e3a03009 mov r3, #9 <== NOT EXECUTED
28ed0: e5803000 str r3, [r0] <== NOT EXECUTED
28ed4: e3e00000 mvn r0, #0 <== NOT EXECUTED
28ed8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
28edc: eb006843 bl 42ff0 <__errno> <== NOT EXECUTED
28ee0: e3a03016 mov r3, #22 <== NOT EXECUTED
28ee4: e5803000 str r3, [r0] <== NOT EXECUTED
28ee8: e3e00000 mvn r0, #0 <== NOT EXECUTED
28eec: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( !iop->pathinfo.ops->chown_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
28ef0: eb00683e bl 42ff0 <__errno> <== NOT EXECUTED
28ef4: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
28ef8: e5803000 str r3, [r0] <== NOT EXECUTED
28efc: e3e00000 mvn r0, #0 <== NOT EXECUTED
28f00: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0003f7ec <fcntl>:
int fcntl(
int fd,
int cmd,
...
)
{
3f7ec: e92d000e push {r1, r2, r3}
3f7f0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
3f7f4: e59f31d0 ldr r3, [pc, #464] ; 3f9cc <fcntl+0x1e0> 3f7f8: e5933000 ldr r3, [r3]
int fcntl(
int fd,
int cmd,
...
)
{
3f7fc: e24dd004 sub sp, sp, #4
int ret; va_list ap; va_start( ap, cmd );
3f800: e28d2028 add r2, sp, #40 ; 0x28
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
3f804: e1500003 cmp r0, r3
...
)
{
int ret;
va_list ap;
va_start( ap, cmd );
3f808: e58d2000 str r2, [sp]
int fcntl(
int fd,
int cmd,
...
)
{
3f80c: e59d4024 ldr r4, [sp, #36] ; 0x24
int fd2;
int flags;
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
3f810: 2a000061 bcs 3f99c <fcntl+0x1b0>
iop = rtems_libio_iop( fd );
3f814: e59f81b4 ldr r8, [pc, #436] ; 3f9d0 <fcntl+0x1e4> 3f818: e5986000 ldr r6, [r8] 3f81c: e0865300 add r5, r6, r0, lsl #6
rtems_libio_check_is_open(iop);
3f820: e595c014 ldr ip, [r5, #20] 3f824: e31c0c01 tst ip, #256 ; 0x100
3f828: 0a00005b beq 3f99c <fcntl+0x1b0>
/*
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
3f82c: e3540009 cmp r4, #9 3f830: 979ff104 ldrls pc, [pc, r4, lsl #2] 3f834: ea00002c b 3f8ec <fcntl+0x100> 3f838: 0003f900 .word 0x0003f900 3f83c: 0003f960 .word 0x0003f960 3f840: 0003f96c .word 0x0003f96c 3f844: 0003f98c .word 0x0003f98c 3f848: 0003f884 .word 0x0003f884 3f84c: 0003f860 .word 0x0003f860 3f850: 0003f860 .word 0x0003f860 3f854: 0003f860 .word 0x0003f860 3f858: 0003f860 .word 0x0003f860 3f85c: 0003f860 .word 0x0003f860
errno = ENOTSUP;
ret = -1;
break;
case F_GETOWN: /* for sockets. */
errno = ENOTSUP;
3f860: eb000de2 bl 42ff0 <__errno> 3f864: e3a03086 mov r3, #134 ; 0x86 3f868: e5803000 str r3, [r0] 3f86c: e3e06000 mvn r6, #0
va_list ap; va_start( ap, cmd ); ret = vfcntl(fd,cmd,ap); va_end(ap); return ret; }
3f870: e1a00006 mov r0, r6
3f874: e28dd004 add sp, sp, #4
3f878: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
3f87c: e28dd00c add sp, sp, #12
3f880: e12fff1e bx lr
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
break;
case F_SETFL:
flags = rtems_libio_fcntl_flags( va_arg( ap, int ) );
3f884: e5920000 ldr r0, [r2] 3f888: ebff2289 bl 82b4 <rtems_libio_fcntl_flags>
/*
* XXX If we are turning on append, should we seek to the end?
*/
iop->flags = (iop->flags & ~mask) | (flags & mask);
3f88c: e5953014 ldr r3, [r5, #20] 3f890: e3c00f7f bic r0, r0, #508 ; 0x1fc 3f894: e3c00002 bic r0, r0, #2 3f898: e1a00b00 lsl r0, r0, #22 3f89c: e3c33c02 bic r3, r3, #512 ; 0x200 3f8a0: e1a00b20 lsr r0, r0, #22 3f8a4: e3c33001 bic r3, r3, #1 3f8a8: e1800003 orr r0, r0, r3 3f8ac: e5850014 str r0, [r5, #20] 3f8b0: e3a06000 mov r6, #0
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
if (iop->handlers->fcntl_h) {
3f8b4: e595303c ldr r3, [r5, #60] ; 0x3c 3f8b8: e5933030 ldr r3, [r3, #48] ; 0x30 3f8bc: e3530000 cmp r3, #0
3f8c0: 0affffea beq 3f870 <fcntl+0x84>
int err = (*iop->handlers->fcntl_h)( cmd, iop );
3f8c4: e1a00004 mov r0, r4 3f8c8: e1a01005 mov r1, r5 3f8cc: e1a0e00f mov lr, pc 3f8d0: e12fff13 bx r3
if (err) {
3f8d4: e2504000 subs r4, r0, #0
3f8d8: 0affffe4 beq 3f870 <fcntl+0x84>
errno = err;
3f8dc: eb000dc3 bl 42ff0 <__errno> <== NOT EXECUTED 3f8e0: e5804000 str r4, [r0] <== NOT EXECUTED 3f8e4: e3e06000 mvn r6, #0 <== NOT EXECUTED 3f8e8: eaffffe0 b 3f870 <fcntl+0x84> <== NOT EXECUTED
errno = ENOTSUP;
ret = -1;
break;
default:
errno = EINVAL;
3f8ec: eb000dbf bl 42ff0 <__errno> 3f8f0: e3a03016 mov r3, #22 3f8f4: e5803000 str r3, [r0] 3f8f8: e3e06000 mvn r6, #0 3f8fc: eaffffdb b 3f870 <fcntl+0x84>
* This switch should contain all the cases from POSIX.
*/
switch ( cmd ) {
case F_DUPFD: /* dup */
fd2 = va_arg( ap, int );
3f900: e5927000 ldr r7, [r2]
if ( fd2 )
3f904: e3570000 cmp r7, #0
3f908: 0a000028 beq 3f9b0 <fcntl+0x1c4>
diop = rtems_libio_iop( fd2 );
3f90c: e1530007 cmp r3, r7 <== NOT EXECUTED 3f910: 93a09000 movls r9, #0 <== NOT EXECUTED 3f914: 80867307 addhi r7, r6, r7, lsl #6 <== NOT EXECUTED 3f918: 91a07009 movls r7, r9 <== NOT EXECUTED 3f91c: 81a09007 movhi r9, r7 <== NOT EXECUTED
}
diop->handlers = iop->handlers;
diop->file_info = iop->file_info;
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
3f920: e2858018 add r8, r5, #24
3f924: e8b8000f ldm r8!, {r0, r1, r2, r3}
3f928: e287a018 add sl, r7, #24
3f92c: e8aa000f stmia sl!, {r0, r1, r2, r3}
ret = -1;
break;
}
}
diop->handlers = iop->handlers;
3f930: e595203c ldr r2, [r5, #60] ; 0x3c
diop->file_info = iop->file_info;
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
3f934: e5981000 ldr r1, [r8]
break;
}
}
diop->handlers = iop->handlers;
diop->file_info = iop->file_info;
3f938: e5953038 ldr r3, [r5, #56] ; 0x38
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
ret = (int) (diop - rtems_libio_iops);
3f93c: e0666009 rsb r6, r6, r9
}
diop->handlers = iop->handlers;
diop->file_info = iop->file_info;
diop->flags = iop->flags;
diop->pathinfo = iop->pathinfo;
3f940: e58a1000 str r1, [sl]
ret = -1;
break;
}
}
diop->handlers = iop->handlers;
3f944: e587203c str r2, [r7, #60] ; 0x3c
diop->file_info = iop->file_info;
3f948: e5873038 str r3, [r7, #56] ; 0x38
diop->flags = iop->flags;
3f94c: e587c014 str ip, [r7, #20]
diop->pathinfo = iop->pathinfo;
ret = (int) (diop - rtems_libio_iops);
3f950: e1a06346 asr r6, r6, #6
/*
* If we got this far successfully, then we give the optional
* filesystem specific handler a chance to process this.
*/
if (ret >= 0) {
3f954: e3560000 cmp r6, #0
3f958: aaffffd5 bge 3f8b4 <fcntl+0xc8>
3f95c: eaffffc3 b 3f870 <fcntl+0x84> <== NOT EXECUTED
diop->pathinfo = iop->pathinfo;
ret = (int) (diop - rtems_libio_iops);
break;
case F_GETFD: /* get f_flags */
ret = ((iop->flags & LIBIO_FLAGS_CLOSE_ON_EXEC) != 0);
3f960: e1a0c5ac lsr ip, ip, #11 3f964: e20c6001 and r6, ip, #1 3f968: eaffffd1 b 3f8b4 <fcntl+0xc8>
* if a new process is exec()'ed. Since RTEMS does not support
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
3f96c: e5926000 ldr r6, [r2] 3f970: e3560000 cmp r6, #0
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
3f974: 138ccb02 orrne ip, ip, #2048 ; 0x800
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
3f978: 03cccb02 biceq ip, ip, #2048 ; 0x800
* processes, then we can ignore this one except to make
* F_GETFD work.
*/
if ( va_arg( ap, int ) )
iop->flags |= LIBIO_FLAGS_CLOSE_ON_EXEC;
3f97c: 1585c014 strne ip, [r5, #20] 3f980: 13a06000 movne r6, #0
else
iop->flags &= ~LIBIO_FLAGS_CLOSE_ON_EXEC;
3f984: 0585c014 streq ip, [r5, #20] 3f988: eaffffc9 b 3f8b4 <fcntl+0xc8>
break;
case F_GETFL: /* more flags (cloexec) */
ret = rtems_libio_to_fcntl_flags( iop->flags );
3f98c: e1a0000c mov r0, ip 3f990: ebff21a7 bl 8034 <rtems_libio_to_fcntl_flags> 3f994: e1a06000 mov r6, r0 3f998: eaffffed b 3f954 <fcntl+0x168>
int mask;
int ret = 0;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
3f99c: eb000d93 bl 42ff0 <__errno> <== NOT EXECUTED 3f9a0: e3a03009 mov r3, #9 <== NOT EXECUTED 3f9a4: e5803000 str r3, [r0] <== NOT EXECUTED 3f9a8: e3e06000 mvn r6, #0 <== NOT EXECUTED 3f9ac: eaffffaf b 3f870 <fcntl+0x84> <== NOT EXECUTED
fd2 = va_arg( ap, int );
if ( fd2 )
diop = rtems_libio_iop( fd2 );
else {
/* allocate a file control block */
diop = rtems_libio_allocate();
3f9b0: ebff2211 bl 81fc <rtems_libio_allocate>
if ( diop == 0 ) {
3f9b4: e2507000 subs r7, r0, #0
3f9b8: 0affffc9 beq 3f8e4 <fcntl+0xf8>
3f9bc: e5986000 ldr r6, [r8] 3f9c0: e595c014 ldr ip, [r5, #20] 3f9c4: e1a09007 mov r9, r7 3f9c8: eaffffd4 b 3f920 <fcntl+0x134>
00002c08 <fdatasync>:
int fd
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2c08: e59f3070 ldr r3, [pc, #112] ; 2c80 <fdatasync+0x78>
2c0c: e5933000 ldr r3, [r3]
2c10: e1500003 cmp r0, r3
#include <rtems/seterr.h>
int fdatasync(
int fd
)
{
2c14: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
2c18: 2a00000e bcs 2c58 <fdatasync+0x50>
iop = rtems_libio_iop( fd );
2c1c: e59f3060 ldr r3, [pc, #96] ; 2c84 <fdatasync+0x7c>
2c20: e5933000 ldr r3, [r3]
2c24: e0830300 add r0, r3, r0, lsl #6
rtems_libio_check_is_open(iop);
2c28: e5903014 ldr r3, [r0, #20]
2c2c: e3130c01 tst r3, #256 ; 0x100
2c30: 0a000008 beq 2c58 <fdatasync+0x50>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
2c34: e3130004 tst r3, #4
2c38: 0a000006 beq 2c58 <fdatasync+0x50>
/*
* Now process the fdatasync().
*/
if ( !iop->handlers->fdatasync_h )
2c3c: e590303c ldr r3, [r0, #60] ; 0x3c
2c40: e593302c ldr r3, [r3, #44] ; 0x2c
2c44: e3530000 cmp r3, #0
2c48: 0a000007 beq 2c6c <fdatasync+0x64>
rtems_set_errno_and_return_minus_one( ENOTSUP );
return (*iop->handlers->fdatasync_h)( iop );
2c4c: e1a0e00f mov lr, pc <== NOT EXECUTED
2c50: e12fff13 bx r3 <== NOT EXECUTED
}
2c54: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
2c58: eb003278 bl f640 <__errno>
2c5c: e3a03009 mov r3, #9
2c60: e5803000 str r3, [r0]
2c64: e3e00000 mvn r0, #0
2c68: e49df004 pop {pc} ; (ldr pc, [sp], #4)
/*
* Now process the fdatasync().
*/
if ( !iop->handlers->fdatasync_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
2c6c: eb003273 bl f640 <__errno>
2c70: e3a03086 mov r3, #134 ; 0x86
2c74: e5803000 str r3, [r0]
2c78: e3e00000 mvn r0, #0
2c7c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
00009620 <fifo_open>:
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
9620: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
)
{
pipe_control_t *pipe;
int err = 0;
if (rtems_semaphore_obtain(rtems_pipe_semaphore,
9624: e59f53bc ldr r5, [pc, #956] ; 99e8 <fifo_open+0x3c8>
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
9628: e1a07001 mov r7, r1
)
{
pipe_control_t *pipe;
int err = 0;
if (rtems_semaphore_obtain(rtems_pipe_semaphore,
962c: e3a01000 mov r1, #0
*/
int fifo_open(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
9630: e24dd008 sub sp, sp, #8
9634: e1a04000 mov r4, r0
)
{
pipe_control_t *pipe;
int err = 0;
if (rtems_semaphore_obtain(rtems_pipe_semaphore,
9638: e1a02001 mov r2, r1
963c: e5950000 ldr r0, [r5]
9640: ebfff059 bl 57ac <rtems_semaphore_obtain>
9644: e2509000 subs r9, r0, #0
9648: 13e08003 mvnne r8, #3
964c: 1a00001c bne 96c4 <fifo_open+0xa4>
RTEMS_WAIT, RTEMS_NO_TIMEOUT) != RTEMS_SUCCESSFUL)
return -EINTR;
pipe = *pipep;
9650: e5946000 ldr r6, [r4] <== NOT EXECUTED
if (pipe == NULL) {
9654: e3560000 cmp r6, #0 <== NOT EXECUTED
9658: 0a00001c beq 96d0 <fifo_open+0xb0> <== NOT EXECUTED
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
965c: e3a01000 mov r1, #0 <== NOT EXECUTED
9660: e5960028 ldr r0, [r6, #40] ; 0x28 <== NOT EXECUTED
9664: e1a02001 mov r2, r1 <== NOT EXECUTED
9668: ebfff04f bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
err = -EINTR;
if (*pipep == NULL) {
966c: e5943000 ldr r3, [r4] <== NOT EXECUTED
err = pipe_alloc(&pipe);
if (err)
goto out;
}
if (! PIPE_LOCK(pipe))
9670: e3500000 cmp r0, #0 <== NOT EXECUTED
9674: 01a08000 moveq r8, r0 <== NOT EXECUTED
9678: 13e08003 mvnne r8, #3 <== NOT EXECUTED
err = -EINTR;
if (*pipep == NULL) {
967c: e3530000 cmp r3, #0 <== NOT EXECUTED
9680: 0a0000ab beq 9934 <fifo_open+0x314> <== NOT EXECUTED
else
*pipep = pipe;
}
out:
rtems_semaphore_release(rtems_pipe_semaphore);
9684: e5950000 ldr r0, [r5] <== NOT EXECUTED
9688: ebfff08f bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
pipe_control_t *pipe;
unsigned int prevCounter;
int err;
err = pipe_new(pipep);
if (err)
968c: e3580000 cmp r8, #0 <== NOT EXECUTED
9690: 1a00000b bne 96c4 <fifo_open+0xa4> <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
9694: e5973014 ldr r3, [r7, #20] <== NOT EXECUTED
9698: e2033006 and r3, r3, #6 <== NOT EXECUTED
969c: e3530004 cmp r3, #4 <== NOT EXECUTED
int err;
err = pipe_new(pipep);
if (err)
return err;
pipe = *pipep;
96a0: e5945000 ldr r5, [r4] <== NOT EXECUTED
switch (LIBIO_ACCMODE(iop)) {
96a4: 0a000082 beq 98b4 <fifo_open+0x294> <== NOT EXECUTED
96a8: e3530006 cmp r3, #6 <== NOT EXECUTED
96ac: 0a00006c beq 9864 <fifo_open+0x244> <== NOT EXECUTED
96b0: e3530002 cmp r3, #2 <== NOT EXECUTED
96b4: 0a000046 beq 97d4 <fifo_open+0x1b4> <== NOT EXECUTED
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
96b8: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
96bc: ebfff082 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
96c0: e3a08000 mov r8, #0 <== NOT EXECUTED
return 0;
out_error:
pipe_release(pipep, iop);
return err;
}
96c4: e1a00008 mov r0, r8
96c8: e28dd008 add sp, sp, #8
96cc: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
96d0: e3a00034 mov r0, #52 ; 0x34 <== NOT EXECUTED
96d4: ebffe34c bl 240c <malloc> <== NOT EXECUTED
if (pipe == NULL)
96d8: e3500000 cmp r0, #0 <== NOT EXECUTED
{
static char c = 'a';
pipe_control_t *pipe;
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
96dc: e1a06000 mov r6, r0 <== NOT EXECUTED
96e0: e1a0a000 mov sl, r0 <== NOT EXECUTED
if (pipe == NULL)
96e4: 0a0000bd beq 99e0 <fifo_open+0x3c0> <== NOT EXECUTED
return err;
memset(pipe, 0, sizeof(pipe_control_t));
96e8: e1a02000 mov r2, r0 <== NOT EXECUTED
96ec: e4829004 str r9, [r2], #4 <== NOT EXECUTED
96f0: e2822004 add r2, r2, #4 <== NOT EXECUTED
96f4: e4829004 str r9, [r2], #4 <== NOT EXECUTED
96f8: e4829004 str r9, [r2], #4 <== NOT EXECUTED
96fc: e4829004 str r9, [r2], #4 <== NOT EXECUTED
9700: e4829004 str r9, [r2], #4 <== NOT EXECUTED
9704: e4829004 str r9, [r2], #4 <== NOT EXECUTED
9708: e4829004 str r9, [r2], #4 <== NOT EXECUTED
970c: e4829004 str r9, [r2], #4 <== NOT EXECUTED
9710: e4829004 str r9, [r2], #4 <== NOT EXECUTED
9714: e4829004 str r9, [r2], #4 <== NOT EXECUTED
9718: e4829004 str r9, [r2], #4 <== NOT EXECUTED
pipe->Size = PIPE_BUF;
971c: e3a03c02 mov r3, #512 ; 0x200 <== NOT EXECUTED
int err = -ENOMEM;
pipe = malloc(sizeof(pipe_control_t));
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
9720: e5829000 str r9, [r2] <== NOT EXECUTED
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
9724: e1a00003 mov r0, r3 <== NOT EXECUTED
pipe = malloc(sizeof(pipe_control_t));
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
pipe->Size = PIPE_BUF;
9728: e5863004 str r3, [r6, #4] <== NOT EXECUTED
pipe->Buffer = malloc(pipe->Size);
972c: ebffe336 bl 240c <malloc> <== NOT EXECUTED
if (! pipe->Buffer)
9730: e3500000 cmp r0, #0 <== NOT EXECUTED
if (pipe == NULL)
return err;
memset(pipe, 0, sizeof(pipe_control_t));
pipe->Size = PIPE_BUF;
pipe->Buffer = malloc(pipe->Size);
9734: e5860000 str r0, [r6] <== NOT EXECUTED
if (! pipe->Buffer)
9738: 0a0000a6 beq 99d8 <fifo_open+0x3b8> <== NOT EXECUTED
goto err_buf;
err = -ENOMEM;
if (rtems_barrier_create(
973c: e59f82a8 ldr r8, [pc, #680] ; 99ec <fifo_open+0x3cc> <== NOT EXECUTED
9740: e5d80000 ldrb r0, [r8] <== NOT EXECUTED
9744: e3800205 orr r0, r0, #1342177280 ; 0x50000000 <== NOT EXECUTED
9748: e3800849 orr r0, r0, #4784128 ; 0x490000 <== NOT EXECUTED
974c: e1a01009 mov r1, r9 <== NOT EXECUTED
9750: e3800c72 orr r0, r0, #29184 ; 0x7200 <== NOT EXECUTED
9754: e1a02009 mov r2, r9 <== NOT EXECUTED
9758: e286302c add r3, r6, #44 ; 0x2c <== NOT EXECUTED
975c: eb0006df bl b2e0 <rtems_barrier_create> <== NOT EXECUTED
9760: e2501000 subs r1, r0, #0 <== NOT EXECUTED
9764: 1a000099 bne 99d0 <fifo_open+0x3b0> <== NOT EXECUTED
rtems_build_name ('P', 'I', 'r', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->readBarrier) != RTEMS_SUCCESSFUL)
goto err_rbar;
if (rtems_barrier_create(
9768: e5d80000 ldrb r0, [r8] <== NOT EXECUTED
976c: e3800205 orr r0, r0, #1342177280 ; 0x50000000 <== NOT EXECUTED
9770: e3800849 orr r0, r0, #4784128 ; 0x490000 <== NOT EXECUTED
9774: e2863030 add r3, r6, #48 ; 0x30 <== NOT EXECUTED
9778: e3800c77 orr r0, r0, #30464 ; 0x7700 <== NOT EXECUTED
977c: e1a02001 mov r2, r1 <== NOT EXECUTED
9780: eb0006d6 bl b2e0 <rtems_barrier_create> <== NOT EXECUTED
9784: e2503000 subs r3, r0, #0 <== NOT EXECUTED
9788: 1a00008e bne 99c8 <fifo_open+0x3a8> <== NOT EXECUTED
rtems_build_name ('P', 'I', 'w', c),
RTEMS_BARRIER_MANUAL_RELEASE, 0,
&pipe->writeBarrier) != RTEMS_SUCCESSFUL)
goto err_wbar;
if (rtems_semaphore_create(
978c: e5d80000 ldrb r0, [r8] <== NOT EXECUTED
9790: e3800205 orr r0, r0, #1342177280 ; 0x50000000 <== NOT EXECUTED
9794: e3800849 orr r0, r0, #4784128 ; 0x490000 <== NOT EXECUTED
9798: e286c028 add ip, r6, #40 ; 0x28 <== NOT EXECUTED
979c: e3800c73 orr r0, r0, #29440 ; 0x7300 <== NOT EXECUTED
97a0: e3a01001 mov r1, #1 <== NOT EXECUTED
97a4: e3a02010 mov r2, #16 <== NOT EXECUTED
97a8: e58dc000 str ip, [sp] <== NOT EXECUTED
97ac: ebffef63 bl 5540 <rtems_semaphore_create> <== NOT EXECUTED
97b0: e3500000 cmp r0, #0 <== NOT EXECUTED
97b4: 1a000081 bne 99c0 <fifo_open+0x3a0> <== NOT EXECUTED
#ifdef RTEMS_POSIX_API
pipe_interruptible(pipe);
#endif
*pipep = pipe;
if (c ++ == 'z')
97b8: e5d83000 ldrb r3, [r8] <== NOT EXECUTED
97bc: e353007a cmp r3, #122 ; 0x7a <== NOT EXECUTED
97c0: e2833001 add r3, r3, #1 <== NOT EXECUTED
97c4: e5c83000 strb r3, [r8] <== NOT EXECUTED
c = 'a';
97c8: 03a03061 moveq r3, #97 ; 0x61 <== NOT EXECUTED
97cc: 05c83000 strbeq r3, [r8] <== NOT EXECUTED
97d0: eaffffa1 b 965c <fifo_open+0x3c> <== NOT EXECUTED
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
97d4: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
97d8: e5952020 ldr r2, [r5, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
97dc: e3530000 cmp r3, #0 <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
97e0: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (pipe->Readers ++ == 0)
97e4: e2833001 add r3, r3, #1 <== NOT EXECUTED
return err;
pipe = *pipep;
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
97e8: e5852020 str r2, [r5, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
97ec: e5853010 str r3, [r5, #16] <== NOT EXECUTED
97f0: 0a00006a beq 99a0 <fifo_open+0x380> <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
if (pipe->Writers == 0) {
97f4: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
97f8: e3530000 cmp r3, #0 <== NOT EXECUTED
97fc: 1affffad bne 96b8 <fifo_open+0x98> <== NOT EXECUTED
/* Not an error */
if (LIBIO_NODELAY(iop))
9800: e5973014 ldr r3, [r7, #20] <== NOT EXECUTED
9804: e3130001 tst r3, #1 <== NOT EXECUTED
9808: 1affffaa bne 96b8 <fifo_open+0x98> <== NOT EXECUTED
break;
prevCounter = pipe->writerCounter;
980c: e5956024 ldr r6, [r5, #36] ; 0x24 <== NOT EXECUTED
9810: ea000006 b 9830 <fifo_open+0x210> <== NOT EXECUTED
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
9814: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
9818: ebffefe3 bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
981c: e3500000 cmp r0, #0 <== NOT EXECUTED
9820: 1a00000a bne 9850 <fifo_open+0x230> <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->writerCounter);
9824: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED
9828: e1530006 cmp r3, r6 <== NOT EXECUTED
982c: 1affffa1 bne 96b8 <fifo_open+0x98> <== NOT EXECUTED
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
9830: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
9834: ebfff024 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_READWAIT(pipe))
9838: e3a01000 mov r1, #0 <== NOT EXECUTED
983c: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED
9840: eb00070a bl b470 <rtems_barrier_wait> <== NOT EXECUTED
9844: e2501000 subs r1, r0, #0 <== NOT EXECUTED
goto out_error;
if (! PIPE_LOCK(pipe))
9848: e1a02001 mov r2, r1 <== NOT EXECUTED
prevCounter = pipe->writerCounter;
err = -EINTR;
/* Wait until a writer opens the pipe */
do {
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
984c: 0afffff0 beq 9814 <fifo_open+0x1f4> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
break;
}
PIPE_UNLOCK(pipe);
return 0;
9850: e3e08003 mvn r8, #3 <== NOT EXECUTED
out_error:
pipe_release(pipep, iop);
9854: e1a00004 mov r0, r4 <== NOT EXECUTED
9858: e1a01007 mov r1, r7 <== NOT EXECUTED
985c: ebffff29 bl 9508 <pipe_release> <== NOT EXECUTED
return err;
9860: eaffff97 b 96c4 <fifo_open+0xa4> <== NOT EXECUTED
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
9864: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
9868: e5952020 ldr r2, [r5, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
986c: e3530000 cmp r3, #0 <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
9870: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (pipe->Readers ++ == 0)
9874: e2833001 add r3, r3, #1 <== NOT EXECUTED
} while (prevCounter == pipe->readerCounter);
}
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
9878: e5852020 str r2, [r5, #32] <== NOT EXECUTED
if (pipe->Readers ++ == 0)
987c: e5853010 str r3, [r5, #16] <== NOT EXECUTED
9880: 0a00003e beq 9980 <fifo_open+0x360> <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
9884: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
9888: e5952024 ldr r2, [r5, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
988c: e3530000 cmp r3, #0 <== NOT EXECUTED
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
9890: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
9894: e2833001 add r3, r3, #1 <== NOT EXECUTED
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
pipe->writerCounter ++;
9898: e5852024 str r2, [r5, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
989c: e5853014 str r3, [r5, #20] <== NOT EXECUTED
98a0: 1affff84 bne 96b8 <fifo_open+0x98> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
98a4: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED
98a8: e28d1004 add r1, sp, #4 <== NOT EXECUTED
98ac: eb0006d6 bl b40c <rtems_barrier_release> <== NOT EXECUTED
98b0: eaffff80 b 96b8 <fifo_open+0x98> <== NOT EXECUTED
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
98b4: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
98b8: e5952024 ldr r2, [r5, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
98bc: e3530000 cmp r3, #0 <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
98c0: e2822001 add r2, r2, #1 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
98c4: e2833001 add r3, r3, #1 <== NOT EXECUTED
} while (prevCounter == pipe->writerCounter);
}
break;
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
98c8: e5852024 str r2, [r5, #36] ; 0x24 <== NOT EXECUTED
if (pipe->Writers ++ == 0)
98cc: e5853014 str r3, [r5, #20] <== NOT EXECUTED
98d0: 0a00002e beq 9990 <fifo_open+0x370> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
98d4: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
98d8: e3530000 cmp r3, #0 <== NOT EXECUTED
98dc: 1affff75 bne 96b8 <fifo_open+0x98> <== NOT EXECUTED
98e0: e5973014 ldr r3, [r7, #20] <== NOT EXECUTED
98e4: e3130001 tst r3, #1 <== NOT EXECUTED
err = -ENXIO;
goto out_error;
}
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
98e8: 05956020 ldreq r6, [r5, #32] <== NOT EXECUTED
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
98ec: 0a000007 beq 9910 <fifo_open+0x2f0> <== NOT EXECUTED
98f0: ea00002e b 99b0 <fifo_open+0x390> <== NOT EXECUTED
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
goto out_error;
if (! PIPE_LOCK(pipe))
98f4: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
98f8: ebffefab bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
98fc: e3500000 cmp r0, #0 <== NOT EXECUTED
9900: 1affffd2 bne 9850 <fifo_open+0x230> <== NOT EXECUTED
goto out_error;
} while (prevCounter == pipe->readerCounter);
9904: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED
9908: e1530006 cmp r3, r6 <== NOT EXECUTED
990c: 1affff69 bne 96b8 <fifo_open+0x98> <== NOT EXECUTED
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
9910: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
9914: ebffefec bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_WRITEWAIT(pipe))
9918: e3a01000 mov r1, #0 <== NOT EXECUTED
991c: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED
9920: eb0006d2 bl b470 <rtems_barrier_wait> <== NOT EXECUTED
9924: e2501000 subs r1, r0, #0 <== NOT EXECUTED
goto out_error;
if (! PIPE_LOCK(pipe))
9928: e1a02001 mov r2, r1 <== NOT EXECUTED
if (pipe->Readers == 0) {
prevCounter = pipe->readerCounter;
err = -EINTR;
do {
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
992c: 0afffff0 beq 98f4 <fifo_open+0x2d4> <== NOT EXECUTED
9930: eaffffc6 b 9850 <fifo_open+0x230> <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
err = -EINTR;
if (*pipep == NULL) {
if (err)
9934: e3580000 cmp r8, #0 <== NOT EXECUTED
9938: 1a000003 bne 994c <fifo_open+0x32c> <== NOT EXECUTED
pipe_free(pipe);
else
*pipep = pipe;
993c: e5846000 str r6, [r4] <== NOT EXECUTED
}
out:
rtems_semaphore_release(rtems_pipe_semaphore);
9940: e5950000 ldr r0, [r5] <== NOT EXECUTED
9944: ebffefe0 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
9948: eaffff51 b 9694 <fifo_open+0x74> <== NOT EXECUTED
/* Called with rtems_pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
994c: e596002c ldr r0, [r6, #44] ; 0x2c <== NOT EXECUTED
9950: eb000693 bl b3a4 <rtems_barrier_delete> <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
9954: e5960030 ldr r0, [r6, #48] ; 0x30 <== NOT EXECUTED
9958: eb000691 bl b3a4 <rtems_barrier_delete> <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
995c: e5960028 ldr r0, [r6, #40] ; 0x28 <== NOT EXECUTED
9960: ebffef68 bl 5708 <rtems_semaphore_delete> <== NOT EXECUTED
free(pipe->Buffer);
9964: e5960000 ldr r0, [r6] <== NOT EXECUTED
9968: ebffe1ce bl 20a8 <free> <== NOT EXECUTED
free(pipe);
996c: e1a00006 mov r0, r6 <== NOT EXECUTED
9970: ebffe1cc bl 20a8 <free> <== NOT EXECUTED
else
*pipep = pipe;
}
out:
rtems_semaphore_release(rtems_pipe_semaphore);
9974: e5950000 ldr r0, [r5] <== NOT EXECUTED
9978: ebffefd3 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
997c: eaffff50 b 96c4 <fifo_open+0xa4> <== NOT EXECUTED
break;
case LIBIO_FLAGS_READ_WRITE:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
9980: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED
9984: e28d1004 add r1, sp, #4 <== NOT EXECUTED
9988: eb00069f bl b40c <rtems_barrier_release> <== NOT EXECUTED
998c: eaffffbc b 9884 <fifo_open+0x264> <== NOT EXECUTED
case LIBIO_FLAGS_WRITE:
pipe->writerCounter ++;
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
9990: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED
9994: e28d1004 add r1, sp, #4 <== NOT EXECUTED
9998: eb00069b bl b40c <rtems_barrier_release> <== NOT EXECUTED
999c: eaffffcc b 98d4 <fifo_open+0x2b4> <== NOT EXECUTED
switch (LIBIO_ACCMODE(iop)) {
case LIBIO_FLAGS_READ:
pipe->readerCounter ++;
if (pipe->Readers ++ == 0)
PIPE_WAKEUPWRITERS(pipe);
99a0: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED
99a4: e28d1004 add r1, sp, #4 <== NOT EXECUTED
99a8: eb000697 bl b40c <rtems_barrier_release> <== NOT EXECUTED
99ac: eaffff90 b 97f4 <fifo_open+0x1d4> <== NOT EXECUTED
if (pipe->Writers ++ == 0)
PIPE_WAKEUPREADERS(pipe);
if (pipe->Readers == 0 && LIBIO_NODELAY(iop)) {
PIPE_UNLOCK(pipe);
99b0: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
99b4: ebffefc4 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
99b8: e3e08005 mvn r8, #5 <== NOT EXECUTED
err = -ENXIO;
goto out_error;
99bc: eaffffa4 b 9854 <fifo_open+0x234> <== NOT EXECUTED
if (c ++ == 'z')
c = 'a';
return 0;
err_sem:
rtems_barrier_delete(pipe->writeBarrier);
99c0: e5960030 ldr r0, [r6, #48] ; 0x30 <== NOT EXECUTED
99c4: eb000676 bl b3a4 <rtems_barrier_delete> <== NOT EXECUTED
err_wbar: rtems_barrier_delete(pipe->readBarrier);
99c8: e59a002c ldr r0, [sl, #44] ; 0x2c <== NOT EXECUTED
99cc: eb000674 bl b3a4 <rtems_barrier_delete> <== NOT EXECUTED
err_rbar: free(pipe->Buffer);
99d0: e59a0000 ldr r0, [sl] <== NOT EXECUTED
99d4: ebffe1b3 bl 20a8 <free> <== NOT EXECUTED
err_buf: free(pipe);
99d8: e1a0000a mov r0, sl <== NOT EXECUTED
99dc: ebffe1b1 bl 20a8 <free> <== NOT EXECUTED
99e0: e3e0800b mvn r8, #11 <== NOT EXECUTED
99e4: eaffffe2 b 9974 <fifo_open+0x354> <== NOT EXECUTED
00002c88 <fpathconf>:
{
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
2c88: e59f30ec ldr r3, [pc, #236] ; 2d7c <fpathconf+0xf4>
2c8c: e5933000 ldr r3, [r3]
2c90: e1500003 cmp r0, r3
long fpathconf(
int fd,
int name
)
{
2c94: e52de004 push {lr} ; (str lr, [sp, #-4]!)
long return_value;
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
2c98: 2a000032 bcs 2d68 <fpathconf+0xe0>
iop = rtems_libio_iop(fd);
2c9c: e59f30dc ldr r3, [pc, #220] ; 2d80 <fpathconf+0xf8>
2ca0: e5933000 ldr r3, [r3]
2ca4: e0830300 add r0, r3, r0, lsl #6
rtems_libio_check_is_open(iop);
2ca8: e5903014 ldr r3, [r0, #20]
2cac: e3130c01 tst r3, #256 ; 0x100
2cb0: 0a00002c beq 2d68 <fpathconf+0xe0>
/*
* Now process the information request.
*/
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
2cb4: e5903028 ldr r3, [r0, #40] ; 0x28
switch ( name ) {
2cb8: e351000b cmp r1, #11
2cbc: 979ff101 ldrls pc, [pc, r1, lsl #2]
2cc0: ea00000d b 2cfc <fpathconf+0x74>
2cc4: 00002d10 .word 0x00002d10
2cc8: 00002d18 .word 0x00002d18
2ccc: 00002d20 .word 0x00002d20
2cd0: 00002d28 .word 0x00002d28
2cd4: 00002d30 .word 0x00002d30
2cd8: 00002d38 .word 0x00002d38
2cdc: 00002d40 .word 0x00002d40
2ce0: 00002d48 .word 0x00002d48
2ce4: 00002d50 .word 0x00002d50
2ce8: 00002d58 .word 0x00002d58
2cec: 00002d60 .word 0x00002d60
2cf0: 00002cf4 .word 0x00002cf4
break;
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
break;
case _PC_SYNC_IO:
return_value = the_limits->posix_sync_io;
2cf4: e5930060 ldr r0, [r3, #96] ; 0x60
break;
2cf8: e49df004 pop {pc} ; (ldr pc, [sp], #4)
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2cfc: eb00324f bl f640 <__errno>
2d00: e3a03016 mov r3, #22
2d04: e5803000 str r3, [r0]
2d08: e3e00000 mvn r0, #0
break;
}
return return_value;
}
2d0c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
the_limits = &iop->pathinfo.mt_entry->pathconf_limits_and_options;
switch ( name ) {
case _PC_LINK_MAX:
return_value = the_limits->link_max;
2d10: e5930038 ldr r0, [r3, #56] ; 0x38
break;
2d14: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_MAX_CANON:
return_value = the_limits->max_canon;
2d18: e593003c ldr r0, [r3, #60] ; 0x3c
break;
2d1c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_MAX_INPUT:
return_value = the_limits->max_input;
2d20: e5930040 ldr r0, [r3, #64] ; 0x40
break;
2d24: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_NAME_MAX:
return_value = the_limits->name_max;
2d28: e5930044 ldr r0, [r3, #68] ; 0x44
break;
2d2c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PATH_MAX:
return_value = the_limits->path_max;
2d30: e5930048 ldr r0, [r3, #72] ; 0x48
break;
2d34: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PIPE_BUF:
return_value = the_limits->pipe_buf;
2d38: e593004c ldr r0, [r3, #76] ; 0x4c
break;
2d3c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_CHOWN_RESTRICTED:
return_value = the_limits->posix_chown_restrictions;
2d40: e5930054 ldr r0, [r3, #84] ; 0x54
break;
2d44: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_NO_TRUNC:
return_value = the_limits->posix_no_trunc;
2d48: e5930058 ldr r0, [r3, #88] ; 0x58
break;
2d4c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_VDISABLE:
return_value = the_limits->posix_vdisable;
2d50: e5930064 ldr r0, [r3, #100] ; 0x64
break;
2d54: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_ASYNC_IO:
return_value = the_limits->posix_async_io;
2d58: e5930050 ldr r0, [r3, #80] ; 0x50
break;
2d5c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case _PC_PRIO_IO:
return_value = the_limits->posix_prio_io;
2d60: e593005c ldr r0, [r3, #92] ; 0x5c
break;
2d64: e49df004 pop {pc} ; (ldr pc, [sp], #4)
rtems_libio_t *iop;
rtems_filesystem_limits_and_options_t *the_limits;
rtems_libio_check_fd(fd);
iop = rtems_libio_iop(fd);
rtems_libio_check_is_open(iop);
2d68: eb003234 bl f640 <__errno>
2d6c: e3a03009 mov r3, #9
2d70: e5803000 str r3, [r0]
2d74: e3e00000 mvn r0, #0
2d78: e49df004 pop {pc} ; (ldr pc, [sp], #4)
000020a8 <free>:
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
20a8: e59f3088 ldr r3, [pc, #136] ; 2138 <free+0x90>
20ac: e593200c ldr r2, [r3, #12]
20b0: e92d4030 push {r4, r5, lr}
20b4: e2822001 add r2, r2, #1
if ( !ptr )
20b8: e2504000 subs r4, r0, #0
void free(
void *ptr
)
{
MSBUMP(free_calls, 1);
20bc: e583200c str r2, [r3, #12]
if ( !ptr )
20c0: 08bd8030 popeq {r4, r5, pc}
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
20c4: e59f3070 ldr r3, [pc, #112] ; 213c <free+0x94>
20c8: e5933000 ldr r3, [r3]
20cc: e3530003 cmp r3, #3
20d0: 0a000012 beq 2120 <free+0x78>
#endif
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
20d4: e59f3064 ldr r3, [pc, #100] ; 2140 <free+0x98>
20d8: e5933000 ldr r3, [r3]
20dc: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_free)(ptr);
20e0: 11a00004 movne r0, r4
20e4: 11a0e00f movne lr, pc
20e8: 1593f008 ldrne pc, [r3, #8]
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
20ec: e59f5050 ldr r5, [pc, #80] ; 2144 <free+0x9c>
20f0: e1a01004 mov r1, r4
20f4: e5950000 ldr r0, [r5]
20f8: eb001444 bl 7210 <_Protected_heap_Free>
20fc: e3500000 cmp r0, #0
2100: 18bd8030 popne {r4, r5, pc}
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
ptr,
RTEMS_Malloc_Heap->area_begin,
2104: e5952000 ldr r2, [r5] <== NOT EXECUTED
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_free)(ptr);
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
2108: e59f0038 ldr r0, [pc, #56] ; 2148 <free+0xa0> <== NOT EXECUTED
210c: e2822018 add r2, r2, #24 <== NOT EXECUTED
2110: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
2114: e1a01004 mov r1, r4 <== NOT EXECUTED
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
2118: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_free)(ptr);
if ( !_Protected_heap_Free( RTEMS_Malloc_Heap, ptr ) ) {
printk( "Program heap: free of bad pointer %p -- range %p - %p \n",
211c: ea000397 b 2f80 <printk> <== NOT EXECUTED
/*
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
2120: eb00005d bl 229c <malloc_is_system_state_OK>
2124: e3500000 cmp r0, #0
2128: 1affffe9 bne 20d4 <free+0x2c>
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
212c: e1a00004 mov r0, r4 <== NOT EXECUTED
RTEMS_Malloc_Heap->area_begin,
RTEMS_Malloc_Heap->area_end
);
}
}
2130: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
* Do not attempt to free memory if in a critical section or ISR.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
!malloc_is_system_state_OK() ) {
malloc_deferred_free(ptr);
2134: ea00006b b 22e8 <malloc_deferred_free> <== NOT EXECUTED
0002a3c8 <free_user_env>:
static void
free_user_env(void *venv)
{
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
2a3c8: e59f3058 ldr r3, [pc, #88] ; 2a428 <free_user_env+0x60> <== NOT EXECUTED 2a3cc: e1500003 cmp r0, r3 <== NOT EXECUTED
* NOTE: this must be called with
* thread dispatching disabled!
*/
static void
free_user_env(void *venv)
{
2a3d0: e92d4010 push {r4, lr} <== NOT EXECUTED
2a3d4: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_user_env_t *env = (rtems_user_env_t*) venv ;
if (env != &rtems_global_user_env
2a3d8: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
#ifdef HAVE_USERENV_REFCNT
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
2a3dc: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED 2a3e0: e3530000 cmp r3, #0 <== NOT EXECUTED 2a3e4: 0a000004 beq 2a3fc <free_user_env+0x34> <== NOT EXECUTED 2a3e8: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 2a3ec: e3530000 cmp r3, #0 <== NOT EXECUTED 2a3f0: 12800004 addne r0, r0, #4 <== NOT EXECUTED 2a3f4: 11a0e00f movne lr, pc <== NOT EXECUTED 2a3f8: 112fff13 bxne r3 <== NOT EXECUTED
rtems_filesystem_freenode( &env->root_directory);
2a3fc: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 2a400: e3530000 cmp r3, #0 <== NOT EXECUTED 2a404: 0a000004 beq 2a41c <free_user_env+0x54> <== NOT EXECUTED 2a408: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 2a40c: e3530000 cmp r3, #0 <== NOT EXECUTED 2a410: 12840018 addne r0, r4, #24 <== NOT EXECUTED 2a414: 11a0e00f movne lr, pc <== NOT EXECUTED 2a418: 112fff13 bxne r3 <== NOT EXECUTED
free(env);
2a41c: e1a00004 mov r0, r4 <== NOT EXECUTED
} }
2a420: e8bd4010 pop {r4, lr} <== NOT EXECUTED
&& --env->refcnt <= 0
#endif
) {
rtems_filesystem_freenode( &env->current_directory);
rtems_filesystem_freenode( &env->root_directory);
free(env);
2a424: eaff7651 b 7d70 <free> <== NOT EXECUTED
00019ae4 <fstat>:
int fstat(
int fd,
struct stat *sbuf
)
{
19ae4: e92d4030 push {r4, r5, lr}
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
19ae8: e2515000 subs r5, r1, #0
19aec: 0a000023 beq 19b80 <fstat+0x9c>
/*
* Now process the stat() request.
*/
iop = rtems_libio_iop( fd );
19af0: e59f309c ldr r3, [pc, #156] ; 19b94 <fstat+0xb0> 19af4: e5933000 ldr r3, [r3] 19af8: e1500003 cmp r0, r3
19afc: 2a000015 bcs 19b58 <fstat+0x74>
19b00: e59f3090 ldr r3, [pc, #144] ; 19b98 <fstat+0xb4> 19b04: e5934000 ldr r4, [r3] 19b08: e0844300 add r4, r4, r0, lsl #6
rtems_libio_check_fd( fd ); rtems_libio_check_is_open(iop);
19b0c: e5943014 ldr r3, [r4, #20] 19b10: e3130c01 tst r3, #256 ; 0x100
19b14: 0a00000f beq 19b58 <fstat+0x74>
if ( !iop->handlers )
19b18: e594303c ldr r3, [r4, #60] ; 0x3c 19b1c: e3530000 cmp r3, #0
19b20: 0a00000c beq 19b58 <fstat+0x74>
rtems_set_errno_and_return_minus_one( EBADF );
if ( !iop->handlers->fstat_h )
19b24: e5933018 ldr r3, [r3, #24] 19b28: e3530000 cmp r3, #0
19b2c: 0a00000e beq 19b6c <fstat+0x88>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( sbuf, 0, sizeof(struct stat) );
19b30: e3a01000 mov r1, #0 19b34: e3a02048 mov r2, #72 ; 0x48 19b38: e1a00005 mov r0, r5 19b3c: ebffd429 bl ebe8 <memset>
return (*iop->handlers->fstat_h)( &iop->pathinfo, sbuf );
19b40: e2840018 add r0, r4, #24 19b44: e1a01005 mov r1, r5 19b48: e594303c ldr r3, [r4, #60] ; 0x3c 19b4c: e1a0e00f mov lr, pc 19b50: e593f018 ldr pc, [r3, #24]
}
19b54: e8bd8030 pop {r4, r5, pc}
iop = rtems_libio_iop( fd );
rtems_libio_check_fd( fd );
rtems_libio_check_is_open(iop);
if ( !iop->handlers )
rtems_set_errno_and_return_minus_one( EBADF );
19b58: ebffd1d8 bl e2c0 <__errno>
19b5c: e3a03009 mov r3, #9
19b60: e5803000 str r3, [r0]
19b64: e3e00000 mvn r0, #0
19b68: e8bd8030 pop {r4, r5, pc}
if ( !iop->handlers->fstat_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
19b6c: ebffd1d3 bl e2c0 <__errno> <== NOT EXECUTED
19b70: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
19b74: e5803000 str r3, [r0] <== NOT EXECUTED
19b78: e3e00000 mvn r0, #0 <== NOT EXECUTED
19b7c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !sbuf )
rtems_set_errno_and_return_minus_one( EFAULT );
19b80: ebffd1ce bl e2c0 <__errno>
19b84: e3a0300e mov r3, #14
19b88: e5803000 str r3, [r0]
19b8c: e3e00000 mvn r0, #0
19b90: e8bd8030 pop {r4, r5, pc}
00028fd0 <fsync>:
int fd
)
{
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
28fd0: e59f3070 ldr r3, [pc, #112] ; 29048 <fsync+0x78> 28fd4: e5933000 ldr r3, [r3] 28fd8: e1500003 cmp r0, r3
#include <rtems/seterr.h>
int fsync(
int fd
)
{
28fdc: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
28fe0: 2a00000e bcs 29020 <fsync+0x50>
iop = rtems_libio_iop( fd );
28fe4: e59f3060 ldr r3, [pc, #96] ; 2904c <fsync+0x7c> 28fe8: e5933000 ldr r3, [r3] 28fec: e0830300 add r0, r3, r0, lsl #6
rtems_libio_check_is_open(iop);
28ff0: e5903014 ldr r3, [r0, #20] 28ff4: e3130c01 tst r3, #256 ; 0x100
28ff8: 0a000008 beq 29020 <fsync+0x50>
/*
* Now process the fsync().
*/
if ( !iop->handlers )
28ffc: e590303c ldr r3, [r0, #60] ; 0x3c 29000: e3530000 cmp r3, #0
29004: 0a000005 beq 29020 <fsync+0x50>
rtems_set_errno_and_return_minus_one( EBADF );
if ( !iop->handlers->fsync_h )
29008: e5933028 ldr r3, [r3, #40] ; 0x28 2900c: e3530000 cmp r3, #0
29010: 0a000007 beq 29034 <fsync+0x64>
rtems_set_errno_and_return_minus_one( ENOTSUP );
return (*iop->handlers->fsync_h)( iop );
29014: e1a0e00f mov lr, pc 29018: e12fff13 bx r3
}
2901c: e49df004 pop {pc} ; (ldr pc, [sp], #4)
/*
* Now process the fsync().
*/
if ( !iop->handlers )
rtems_set_errno_and_return_minus_one( EBADF );
29020: eb0067f2 bl 42ff0 <__errno> <== NOT EXECUTED
29024: e3a03009 mov r3, #9 <== NOT EXECUTED
29028: e5803000 str r3, [r0] <== NOT EXECUTED
2902c: e3e00000 mvn r0, #0 <== NOT EXECUTED
29030: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if ( !iop->handlers->fsync_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
29034: eb0067ed bl 42ff0 <__errno>
29038: e3a03086 mov r3, #134 ; 0x86
2903c: e5803000 str r3, [r0]
29040: e3e00000 mvn r0, #0
29044: e49df004 pop {pc} ; (ldr pc, [sp], #4)
0000ac44 <ftruncate>:
int ftruncate(
int fd,
off_t length
)
{
ac44: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
ac48: e59f30fc ldr r3, [pc, #252] ; ad4c <ftruncate+0x108>
ac4c: e5933000 ldr r3, [r3]
ac50: e1500003 cmp r0, r3
int ftruncate(
int fd,
off_t length
)
{
ac54: e24dd014 sub sp, sp, #20
ac58: e1a05001 mov r5, r1
ac5c: e1a06002 mov r6, r2
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
ac60: 2a000025 bcs acfc <ftruncate+0xb8>
iop = rtems_libio_iop( fd );
ac64: e59f30e4 ldr r3, [pc, #228] ; ad50 <ftruncate+0x10c>
ac68: e5934000 ldr r4, [r3]
ac6c: e0844300 add r4, r4, r0, lsl #6
rtems_libio_check_is_open(iop);
ac70: e5943014 ldr r3, [r4, #20]
ac74: e3130c01 tst r3, #256 ; 0x100
ac78: 0a00001f beq acfc <ftruncate+0xb8>
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
ac7c: e3130004 tst r3, #4
ac80: 0a000022 beq ad10 <ftruncate+0xcc>
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
ac84: e284c018 add ip, r4, #24
ac88: e8bc000f ldm ip!, {r0, r1, r2, r3}
ac8c: e1a0700d mov r7, sp
ac90: e8a7000f stmia r7!, {r0, r1, r2, r3}
if ( !loc.ops->node_type_h )
ac94: e59d200c ldr r2, [sp, #12]
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
ac98: e1a03007 mov r3, r7
if ( !loc.ops->node_type_h )
ac9c: e5927010 ldr r7, [r2, #16]
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
aca0: e59c2000 ldr r2, [ip]
if ( !loc.ops->node_type_h )
aca4: e3570000 cmp r7, #0
/*
* Make sure we are not working on a directory
*/
loc = iop->pathinfo;
aca8: e5832000 str r2, [r3]
if ( !loc.ops->node_type_h )
acac: 0a00001c beq ad24 <ftruncate+0xe0>
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
acb0: e1a0000d mov r0, sp
acb4: e1a0e00f mov lr, pc
acb8: e12fff17 bx r7
acbc: e3500001 cmp r0, #1
acc0: 0a00001c beq ad38 <ftruncate+0xf4>
rtems_set_errno_and_return_minus_one( EISDIR );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
acc4: e5943014 ldr r3, [r4, #20]
acc8: e3130004 tst r3, #4
accc: 0a00000f beq ad10 <ftruncate+0xcc>
if ( !iop->handlers->ftruncate_h )
acd0: e594303c ldr r3, [r4, #60] ; 0x3c
acd4: e5933020 ldr r3, [r3, #32]
acd8: e3530000 cmp r3, #0
acdc: 0a000010 beq ad24 <ftruncate+0xe0>
rtems_set_errno_and_return_minus_one( ENOTSUP );
return (*iop->handlers->ftruncate_h)( iop, length );
ace0: e1a00004 mov r0, r4
ace4: e1a01005 mov r1, r5
ace8: e1a02006 mov r2, r6
acec: e1a0e00f mov lr, pc
acf0: e12fff13 bx r3
}
acf4: e28dd014 add sp, sp, #20
acf8: e8bd80f0 pop {r4, r5, r6, r7, pc}
rtems_libio_t *iop;
rtems_filesystem_location_info_t loc;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
acfc: eb000d6f bl e2c0 <__errno> <== NOT EXECUTED
ad00: e3a03009 mov r3, #9 <== NOT EXECUTED
ad04: e5803000 str r3, [r0] <== NOT EXECUTED
ad08: e3e00000 mvn r0, #0 <== NOT EXECUTED
ad0c: eafffff8 b acf4 <ftruncate+0xb0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( EISDIR );
rtems_libio_check_permissions( iop, LIBIO_FLAGS_WRITE );
ad10: eb000d6a bl e2c0 <__errno> <== NOT EXECUTED
ad14: e3a03016 mov r3, #22 <== NOT EXECUTED
ad18: e5803000 str r3, [r0] <== NOT EXECUTED
ad1c: e3e00000 mvn r0, #0 <== NOT EXECUTED
ad20: eafffff3 b acf4 <ftruncate+0xb0> <== NOT EXECUTED
if ( !iop->handlers->ftruncate_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
ad24: eb000d65 bl e2c0 <__errno> <== NOT EXECUTED
ad28: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
ad2c: e5803000 str r3, [r0] <== NOT EXECUTED
ad30: e3e00000 mvn r0, #0 <== NOT EXECUTED
ad34: eaffffee b acf4 <ftruncate+0xb0> <== NOT EXECUTED
loc = iop->pathinfo;
if ( !loc.ops->node_type_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( EISDIR );
ad38: eb000d60 bl e2c0 <__errno>
ad3c: e3a03015 mov r3, #21
ad40: e5803000 str r3, [r0]
ad44: e3e00000 mvn r0, #0
ad48: eaffffe9 b acf4 <ftruncate+0xb0>
0005cba0 <getdents>:
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
5cba0: e59f30b8 ldr r3, [pc, #184] ; 5cc60 <getdents+0xc0> 5cba4: e5933000 ldr r3, [r3] 5cba8: e1500003 cmp r0, r3 5cbac: 359f30b0 ldrcc r3, [pc, #176] ; 5cc64 <getdents+0xc4>
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
5cbb0: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* Get the file control block structure associated with the file descriptor
*/
iop = rtems_libio_iop( dd_fd );
5cbb4: 35934000 ldrcc r4, [r3] 5cbb8: 23a04000 movcs r4, #0 5cbbc: 30844300 addcc r4, r4, r0, lsl #6
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
5cbc0: e284c018 add ip, r4, #24
int getdents(
int dd_fd,
char *dd_buf,
int dd_len
)
{
5cbc4: e24dd014 sub sp, sp, #20 5cbc8: e1a06001 mov r6, r1 5cbcc: e1a05002 mov r5, r2
iop = rtems_libio_iop( dd_fd );
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
5cbd0: e8bc000f ldm ip!, {r0, r1, r2, r3}
5cbd4: e1a0700d mov r7, sp
5cbd8: e8a7000f stmia r7!, {r0, r1, r2, r3}
if ( !loc.ops->node_type_h )
5cbdc: e59d200c ldr r2, [sp, #12]
iop = rtems_libio_iop( dd_fd );
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
5cbe0: e1a03007 mov r3, r7
if ( !loc.ops->node_type_h )
5cbe4: e5927010 ldr r7, [r2, #16]
iop = rtems_libio_iop( dd_fd );
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
5cbe8: e59c2000 ldr r2, [ip]
if ( !loc.ops->node_type_h )
5cbec: e3570000 cmp r7, #0
iop = rtems_libio_iop( dd_fd );
/*
* Make sure we are working on a directory
*/
loc = iop->pathinfo;
5cbf0: e5832000 str r2, [r3]
if ( !loc.ops->node_type_h )
5cbf4: 0a000014 beq 5cc4c <getdents+0xac>
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
5cbf8: e1a0000d mov r0, sp 5cbfc: e1a0e00f mov lr, pc 5cc00: e12fff17 bx r7 5cc04: e3500001 cmp r0, #1
5cc08: 1a00000a bne 5cc38 <getdents+0x98>
/*
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
if ( !iop->handlers->read_h )
5cc0c: e594303c ldr r3, [r4, #60] ; 0x3c 5cc10: e5933008 ldr r3, [r3, #8] 5cc14: e3530000 cmp r3, #0
5cc18: 0a00000b beq 5cc4c <getdents+0xac>
rtems_set_errno_and_return_minus_one( ENOTSUP );
return (*iop->handlers->read_h)( iop, dd_buf, dd_len );
5cc1c: e1a00004 mov r0, r4 5cc20: e1a01006 mov r1, r6 5cc24: e1a02005 mov r2, r5 5cc28: e1a0e00f mov lr, pc 5cc2c: e12fff13 bx r3
}
5cc30: e28dd014 add sp, sp, #20
5cc34: e8bd80f0 pop {r4, r5, r6, r7, pc}
loc = iop->pathinfo;
if ( !loc.ops->node_type_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY )
rtems_set_errno_and_return_minus_one( ENOTDIR );
5cc38: ebff98ec bl 42ff0 <__errno> 5cc3c: e3a03014 mov r3, #20 5cc40: e5803000 str r3, [r0] 5cc44: e3e00000 mvn r0, #0 5cc48: eafffff8 b 5cc30 <getdents+0x90>
* Return the number of bytes that were actually transfered as a result
* of the read attempt.
*/
if ( !iop->handlers->read_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
5cc4c: ebff98e7 bl 42ff0 <__errno> <== NOT EXECUTED 5cc50: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 5cc54: e5803000 str r3, [r0] <== NOT EXECUTED 5cc58: e3e00000 mvn r0, #0 <== NOT EXECUTED 5cc5c: eafffff3 b 5cc30 <getdents+0x90> <== NOT EXECUTED
00029188 <getgid>:
* 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs,
* P1003.1b-1993, p. 84
*/
gid_t getgid( void )
{
29188: e59f3008 ldr r3, [pc, #8] ; 29198 <getgid+0x10> <== NOT EXECUTED 2918c: e5933000 ldr r3, [r3] <== NOT EXECUTED
return _POSIX_types_Gid; }
29190: e1d303b4 ldrh r0, [r3, #52] ; 0x34 <== NOT EXECUTED 29194: e12fff1e bx lr <== NOT EXECUTED
000297e4 <getgr_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
297e4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
297e8: e59d801c ldr r8, [sp, #28]
297ec: e1a05000 mov r5, r0
297f0: e1a0a001 mov sl, r1
297f4: e1a04002 mov r4, r2
297f8: e1a07003 mov r7, r3
FILE *fp;
int match;
init_etc_passwd_group();
297fc: ebffffb2 bl 296cc <init_etc_passwd_group>
if ((fp = fopen("/etc/group", "r")) == NULL) {
29800: e59f00b0 ldr r0, [pc, #176] ; 298b8 <getgr_r+0xd4> 29804: e59f10b0 ldr r1, [pc, #176] ; 298bc <getgr_r+0xd8> 29808: eb006868 bl 439b0 <fopen> 2980c: e2506000 subs r6, r0, #0
29810: 1a000006 bne 29830 <getgr_r+0x4c>
29814: ea000022 b 298a4 <getgr_r+0xc0> <== NOT EXECUTED
errno = EINVAL;
fclose(fp);
return -1;
}
if (name) {
match = (strcmp(grp->gr_name, name) == 0);
29818: e5940000 ldr r0, [r4] 2981c: eb007e88 bl 49244 <strcmp> 29820: e2700001 rsbs r0, r0, #1 29824: 33a00000 movcc r0, #0
}
else {
match = (grp->gr_gid == gid);
}
if (match) {
29828: e3500000 cmp r0, #0
2982c: 1a00000f bne 29870 <getgr_r+0x8c>
if ((fp = fopen("/etc/group", "r")) == NULL) {
errno = EINVAL;
return -1;
}
for(;;) {
if (!scangr(fp, grp, buffer, bufsize)) {
29830: e1a01004 mov r1, r4 29834: e1a02007 mov r2, r7 29838: e1a03008 mov r3, r8 2983c: e1a00006 mov r0, r6 29840: ebfffee1 bl 293cc <scangr> 29844: e3500000 cmp r0, #0
errno = EINVAL;
fclose(fp);
return -1;
}
if (name) {
match = (strcmp(grp->gr_name, name) == 0);
29848: e1a01005 mov r1, r5
if ((fp = fopen("/etc/group", "r")) == NULL) {
errno = EINVAL;
return -1;
}
for(;;) {
if (!scangr(fp, grp, buffer, bufsize)) {
2984c: 0a00000d beq 29888 <getgr_r+0xa4>
errno = EINVAL;
fclose(fp);
return -1;
}
if (name) {
29850: e3550000 cmp r5, #0
29854: 1affffef bne 29818 <getgr_r+0x34>
match = (strcmp(grp->gr_name, name) == 0);
}
else {
match = (grp->gr_gid == gid);
29858: e1d400b8 ldrh r0, [r4, #8] <== NOT EXECUTED 2985c: e150000a cmp r0, sl <== NOT EXECUTED 29860: 13a00000 movne r0, #0 <== NOT EXECUTED 29864: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
if (match) {
29868: e3500000 cmp r0, #0 <== NOT EXECUTED 2986c: 0affffef beq 29830 <getgr_r+0x4c> <== NOT EXECUTED
fclose(fp);
29870: e1a00006 mov r0, r6 29874: eb00662a bl 43124 <fclose>
*result = grp;
29878: e59d3020 ldr r3, [sp, #32] 2987c: e3a00000 mov r0, #0 29880: e5834000 str r4, [r3]
}
}
fclose(fp);
errno = EINVAL;
return -1;
}
29884: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
errno = EINVAL;
return -1;
}
for(;;) {
if (!scangr(fp, grp, buffer, bufsize)) {
errno = EINVAL;
29888: eb0065d8 bl 42ff0 <__errno> <== NOT EXECUTED 2988c: e3a03016 mov r3, #22 <== NOT EXECUTED 29890: e5803000 str r3, [r0] <== NOT EXECUTED
fclose(fp);
29894: e1a00006 mov r0, r6 <== NOT EXECUTED 29898: eb006621 bl 43124 <fclose> <== NOT EXECUTED 2989c: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
298a0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
int match;
init_etc_passwd_group();
if ((fp = fopen("/etc/group", "r")) == NULL) {
errno = EINVAL;
298a4: eb0065d1 bl 42ff0 <__errno> <== NOT EXECUTED 298a8: e3a03016 mov r3, #22 <== NOT EXECUTED 298ac: e5803000 str r3, [r0] <== NOT EXECUTED 298b0: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
298b4: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
00029520 <getgrent>:
return NULL;
return p;
}
struct group *getgrent(void)
{
29520: e92d4010 push {r4, lr} <== NOT EXECUTED
if (group_fp == NULL)
29524: e59f4030 ldr r4, [pc, #48] ; 2955c <getgrent+0x3c> <== NOT EXECUTED 29528: e5940000 ldr r0, [r4] <== NOT EXECUTED 2952c: e3500000 cmp r0, #0 <== NOT EXECUTED 29530: 1a000001 bne 2953c <getgrent+0x1c> <== NOT EXECUTED
return NULL;
if (!scangr(group_fp, &grent, grbuf, sizeof grbuf))
29534: e3a00000 mov r0, #0 <== NOT EXECUTED
return NULL;
return &grent;
}
29538: e8bd8010 pop {r4, pc} <== NOT EXECUTED
struct group *getgrent(void)
{
if (group_fp == NULL)
return NULL;
if (!scangr(group_fp, &grent, grbuf, sizeof grbuf))
2953c: e2841008 add r1, r4, #8 <== NOT EXECUTED
29540: e2842018 add r2, r4, #24 <== NOT EXECUTED
29544: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED
29548: ebffff9f bl 293cc <scangr> <== NOT EXECUTED
2954c: e3500000 cmp r0, #0 <== NOT EXECUTED
29550: 12840008 addne r0, r4, #8 <== NOT EXECUTED
29554: 18bd8010 popne {r4, pc} <== NOT EXECUTED
29558: eafffff5 b 29534 <getgrent+0x14> <== NOT EXECUTED
000298fc <getgrgid>:
struct group *getgrgid(
gid_t gid
)
{
298fc: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
struct group *p;
if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))
29900: e59f1030 ldr r1, [pc, #48] ; 29938 <getgrgid+0x3c> <== NOT EXECUTED
}
struct group *getgrgid(
gid_t gid
)
{
29904: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 29908: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
struct group *p;
if(getgrgid_r(gid, &grent, grbuf, sizeof grbuf, &p))
2990c: e28dc004 add ip, sp, #4 <== NOT EXECUTED 29910: e2812010 add r2, r1, #16 <== NOT EXECUTED 29914: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 29918: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 2991c: e58dc000 str ip, [sp] <== NOT EXECUTED 29920: ebffffe6 bl 298c0 <getgrgid_r> <== NOT EXECUTED 29924: e3500000 cmp r0, #0 <== NOT EXECUTED 29928: 13a00000 movne r0, #0 <== NOT EXECUTED
return NULL;
return p;
2992c: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
}
29930: e28dd008 add sp, sp, #8 <== NOT EXECUTED
29934: e8bd8000 pop {pc} <== NOT EXECUTED
000298c0 <getgrgid_r>:
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
298c0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
298c4: e1a0c002 mov ip, r2 <== NOT EXECUTED
298c8: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
298cc: e1a0e001 mov lr, r1 <== NOT EXECUTED
return getgr_r(NULL, gid, grp, buffer, bufsize, result);
298d0: e58d3000 str r3, [sp] <== NOT EXECUTED
struct group *grp,
char *buffer,
size_t bufsize,
struct group **result
)
{
298d4: e1a01800 lsl r1, r0, #16 <== NOT EXECUTED
return getgr_r(NULL, gid, grp, buffer, bufsize, result);
298d8: e1a0300c mov r3, ip <== NOT EXECUTED 298dc: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 298e0: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 298e4: e1a0200e mov r2, lr <== NOT EXECUTED 298e8: e3a00000 mov r0, #0 <== NOT EXECUTED 298ec: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 298f0: ebffffbb bl 297e4 <getgr_r> <== NOT EXECUTED
}
298f4: e28dd008 add sp, sp, #8 <== NOT EXECUTED
298f8: e8bd8000 pop {pc} <== NOT EXECUTED
00022054 <getpid>:
*/
pid_t getpid( void )
{
return _Objects_Local_node;
}
22054: e3a00001 mov r0, #1 <== NOT EXECUTED 22058: e12fff1e bx lr <== NOT EXECUTED
000299dc <getpw_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
299dc: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
299e0: e59d801c ldr r8, [sp, #28]
299e4: e1a05000 mov r5, r0
299e8: e1a0a001 mov sl, r1
299ec: e1a04002 mov r4, r2
299f0: e1a07003 mov r7, r3
FILE *fp;
int match;
init_etc_passwd_group();
299f4: ebffff34 bl 296cc <init_etc_passwd_group>
if ((fp = fopen("/etc/passwd", "r")) == NULL) {
299f8: e59f00b0 ldr r0, [pc, #176] ; 29ab0 <getpw_r+0xd4> 299fc: e59f10b0 ldr r1, [pc, #176] ; 29ab4 <getpw_r+0xd8> 29a00: eb0067ea bl 439b0 <fopen> 29a04: e2506000 subs r6, r0, #0
29a08: 1a000006 bne 29a28 <getpw_r+0x4c>
29a0c: ea000022 b 29a9c <getpw_r+0xc0> <== NOT EXECUTED
errno = EINVAL;
fclose(fp);
return -1;
}
if (name) {
match = (strcmp(pwd->pw_name, name) == 0);
29a10: e5940000 ldr r0, [r4] 29a14: eb007e0a bl 49244 <strcmp> 29a18: e2700001 rsbs r0, r0, #1 29a1c: 33a00000 movcc r0, #0
}
else {
match = (pwd->pw_uid == uid);
}
if (match) {
29a20: e3500000 cmp r0, #0
29a24: 1a00000f bne 29a68 <getpw_r+0x8c>
if ((fp = fopen("/etc/passwd", "r")) == NULL) {
errno = EINVAL;
return -1;
}
for(;;) {
if (!scanpw(fp, pwd, buffer, bufsize)) {
29a28: e1a01004 mov r1, r4 29a2c: e1a02007 mov r2, r7 29a30: e1a03008 mov r3, r8 29a34: e1a00006 mov r0, r6 29a38: ebfffec8 bl 29560 <scanpw> 29a3c: e3500000 cmp r0, #0
errno = EINVAL;
fclose(fp);
return -1;
}
if (name) {
match = (strcmp(pwd->pw_name, name) == 0);
29a40: e1a01005 mov r1, r5
if ((fp = fopen("/etc/passwd", "r")) == NULL) {
errno = EINVAL;
return -1;
}
for(;;) {
if (!scanpw(fp, pwd, buffer, bufsize)) {
29a44: 0a00000d beq 29a80 <getpw_r+0xa4>
errno = EINVAL;
fclose(fp);
return -1;
}
if (name) {
29a48: e3550000 cmp r5, #0
29a4c: 1affffef bne 29a10 <getpw_r+0x34>
match = (strcmp(pwd->pw_name, name) == 0);
}
else {
match = (pwd->pw_uid == uid);
29a50: e1d400b8 ldrh r0, [r4, #8] <== NOT EXECUTED 29a54: e150000a cmp r0, sl <== NOT EXECUTED 29a58: 13a00000 movne r0, #0 <== NOT EXECUTED 29a5c: 03a00001 moveq r0, #1 <== NOT EXECUTED
}
if (match) {
29a60: e3500000 cmp r0, #0 <== NOT EXECUTED 29a64: 0affffef beq 29a28 <getpw_r+0x4c> <== NOT EXECUTED
fclose(fp);
29a68: e1a00006 mov r0, r6 29a6c: eb0065ac bl 43124 <fclose>
*result = pwd;
29a70: e59d3020 ldr r3, [sp, #32] 29a74: e3a00000 mov r0, #0 29a78: e5834000 str r4, [r3]
}
}
fclose(fp);
errno = EINVAL;
return -1;
}
29a7c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
errno = EINVAL;
return -1;
}
for(;;) {
if (!scanpw(fp, pwd, buffer, bufsize)) {
errno = EINVAL;
29a80: eb00655a bl 42ff0 <__errno> <== NOT EXECUTED 29a84: e3a03016 mov r3, #22 <== NOT EXECUTED 29a88: e5803000 str r3, [r0] <== NOT EXECUTED
fclose(fp);
29a8c: e1a00006 mov r0, r6 <== NOT EXECUTED 29a90: eb0065a3 bl 43124 <fclose> <== NOT EXECUTED 29a94: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
29a98: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
int match;
init_etc_passwd_group();
if ((fp = fopen("/etc/passwd", "r")) == NULL) {
errno = EINVAL;
29a9c: eb006553 bl 42ff0 <__errno> <== NOT EXECUTED 29aa0: e3a03016 mov r3, #22 <== NOT EXECUTED 29aa4: e5803000 str r3, [r0] <== NOT EXECUTED 29aa8: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
29aac: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
0002968c <getpwent>:
return NULL;
return p;
}
struct passwd *getpwent(void)
{
2968c: e92d4010 push {r4, lr} <== NOT EXECUTED
if (passwd_fp == NULL)
29690: e59f4030 ldr r4, [pc, #48] ; 296c8 <getpwent+0x3c> <== NOT EXECUTED 29694: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 29698: e3500000 cmp r0, #0 <== NOT EXECUTED 2969c: 1a000001 bne 296a8 <getpwent+0x1c> <== NOT EXECUTED
return NULL;
if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf))
296a0: e3a00000 mov r0, #0 <== NOT EXECUTED
return NULL;
return &pwent;
}
296a4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
struct passwd *getpwent(void)
{
if (passwd_fp == NULL)
return NULL;
if (!scanpw(passwd_fp, &pwent, pwbuf, sizeof pwbuf))
296a8: e28410e0 add r1, r4, #224 ; 0xe0 <== NOT EXECUTED
296ac: e28420fc add r2, r4, #252 ; 0xfc <== NOT EXECUTED
296b0: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED
296b4: ebffffa9 bl 29560 <scanpw> <== NOT EXECUTED
296b8: e3500000 cmp r0, #0 <== NOT EXECUTED
296bc: 128400e0 addne r0, r4, #224 ; 0xe0 <== NOT EXECUTED
296c0: 18bd8010 popne {r4, pc} <== NOT EXECUTED
296c4: eafffff5 b 296a0 <getpwent+0x14> <== NOT EXECUTED
00029af4 <getpwuid>:
struct passwd *getpwuid(
uid_t uid
)
{
29af4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
struct passwd *p;
if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))
29af8: e59f1030 ldr r1, [pc, #48] ; 29b30 <getpwuid+0x3c> <== NOT EXECUTED
}
struct passwd *getpwuid(
uid_t uid
)
{
29afc: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 29b00: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
struct passwd *p;
if(getpwuid_r(uid, &pwent, pwbuf, sizeof pwbuf, &p))
29b04: e28dc004 add ip, sp, #4 <== NOT EXECUTED 29b08: e281201c add r2, r1, #28 <== NOT EXECUTED 29b0c: e3a030c8 mov r3, #200 ; 0xc8 <== NOT EXECUTED 29b10: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 29b14: e58dc000 str ip, [sp] <== NOT EXECUTED 29b18: ebffffe6 bl 29ab8 <getpwuid_r> <== NOT EXECUTED 29b1c: e3500000 cmp r0, #0 <== NOT EXECUTED 29b20: 13a00000 movne r0, #0 <== NOT EXECUTED
return NULL;
return p;
29b24: 059d0004 ldreq r0, [sp, #4] <== NOT EXECUTED
}
29b28: e28dd008 add sp, sp, #8 <== NOT EXECUTED
29b2c: e8bd8000 pop {pc} <== NOT EXECUTED
00029ab8 <getpwuid_r>:
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
29ab8: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
29abc: e1a0c002 mov ip, r2 <== NOT EXECUTED
29ac0: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
29ac4: e1a0e001 mov lr, r1 <== NOT EXECUTED
return getpw_r(NULL, uid, pwd, buffer, bufsize, result);
29ac8: e58d3000 str r3, [sp] <== NOT EXECUTED
struct passwd *pwd,
char *buffer,
size_t bufsize,
struct passwd **result
)
{
29acc: e1a01800 lsl r1, r0, #16 <== NOT EXECUTED
return getpw_r(NULL, uid, pwd, buffer, bufsize, result);
29ad0: e1a0300c mov r3, ip <== NOT EXECUTED 29ad4: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 29ad8: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 29adc: e1a0200e mov r2, lr <== NOT EXECUTED 29ae0: e3a00000 mov r0, #0 <== NOT EXECUTED 29ae4: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 29ae8: ebffffbb bl 299dc <getpw_r> <== NOT EXECUTED
}
29aec: e28dd008 add sp, sp, #8 <== NOT EXECUTED
29af0: e8bd8000 pop {pc} <== NOT EXECUTED
0000214c <gettimeofday>:
*/
int gettimeofday(
struct timeval *tp,
void * __tz __attribute__((unused))
)
{
214c: e92d4030 push {r4, r5, lr}
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp ) {
2150: e2504000 subs r4, r0, #0
*/
int gettimeofday(
struct timeval *tp,
void * __tz __attribute__((unused))
)
{
2154: e24dd008 sub sp, sp, #8
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp ) {
2158: 0a00000f beq 219c <gettimeofday+0x50>
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
215c: e10f5000 mrs r5, CPSR
2160: e3853080 orr r3, r5, #128 ; 0x80
2164: e129f003 msr CPSR_fc, r3
ISR_Level level;
struct timespec now;
suseconds_t useconds;
_ISR_Disable(level);
_TOD_Get( &now );
2168: e1a0000d mov r0, sp
216c: eb0010df bl 64f0 <_TOD_Get>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
2170: e129f005 msr CPSR_fc, r5
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
time->tv_usec = useconds;
2174: e59f2034 ldr r2, [pc, #52] ; 21b0 <gettimeofday+0x64>
_ISR_Disable(level);
_TOD_Get( &now );
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
2178: e59d3004 ldr r3, [sp, #4]
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
time->tv_usec = useconds;
217c: e0c10392 smull r0, r1, r2, r3
_ISR_Enable(level);
useconds = (suseconds_t)now.tv_nsec;
useconds /= (suseconds_t)TOD_NANOSECONDS_PER_MICROSECOND;
time->tv_sec = now.tv_sec;
2180: e59d2000 ldr r2, [sp]
time->tv_usec = useconds;
2184: e1a03fc3 asr r3, r3, #31
2188: e0633341 rsb r3, r3, r1, asr #6
218c: e884000c stm r4, {r2, r3}
2190: e3a00000 mov r0, #0
* with Eric Norum, this is how GNU/Linux, Solaris, and MacOS X
* do it. This puts us in good company.
*/
return 0;
}
2194: e28dd008 add sp, sp, #8
2198: e8bd8030 pop {r4, r5, pc}
void * __tz __attribute__((unused))
)
{
/* struct timezone* tzp = (struct timezone*) __tz; */
if ( !tp ) {
errno = EFAULT;
219c: eb003047 bl e2c0 <__errno> <== NOT EXECUTED
21a0: e3a0300e mov r3, #14 <== NOT EXECUTED
21a4: e5803000 str r3, [r0] <== NOT EXECUTED
21a8: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
21ac: eafffff8 b 2194 <gettimeofday+0x48> <== NOT EXECUTED
00007e8c <getuid>:
* 4.2.1 Get Real User, Effective User, Ral Group, and Effective Group IDs,
* P1003.1b-1993, p. 84
*/
uid_t getuid( void )
{
7e8c: e59f3008 ldr r3, [pc, #8] ; 7e9c <getuid+0x10> <== NOT EXECUTED
7e90: e5933000 ldr r3, [r3] <== NOT EXECUTED
return _POSIX_types_Uid; }
7e94: e1d303b2 ldrh r0, [r3, #50] ; 0x32 <== NOT EXECUTED
7e98: e12fff1e bx lr <== NOT EXECUTED
00005790 <ioctl>:
int ioctl(
int fd,
ioctl_command_t command,
...
)
{
5790: e92d000e push {r1, r2, r3}
va_list ap;
rtems_status_code rc;
rtems_libio_t *iop;
void *buffer;
rtems_libio_check_fd( fd );
5794: e59f3090 ldr r3, [pc, #144] ; 582c <ioctl+0x9c>
int ioctl(
int fd,
ioctl_command_t command,
...
)
{
5798: e52de004 push {lr} ; (str lr, [sp, #-4]!)
va_list ap;
rtems_status_code rc;
rtems_libio_t *iop;
void *buffer;
rtems_libio_check_fd( fd );
579c: e5933000 ldr r3, [r3]
57a0: e1500003 cmp r0, r3
int ioctl(
int fd,
ioctl_command_t command,
...
)
{
57a4: e24dd004 sub sp, sp, #4
va_list ap;
rtems_status_code rc;
rtems_libio_t *iop;
void *buffer;
rtems_libio_check_fd( fd );
57a8: 2a000015 bcs 5804 <ioctl+0x74>
iop = rtems_libio_iop( fd );
57ac: e59f307c ldr r3, [pc, #124] ; 5830 <ioctl+0xa0>
57b0: e5933000 ldr r3, [r3]
57b4: e0830300 add r0, r3, r0, lsl #6
rtems_libio_check_is_open(iop);
57b8: e5903014 ldr r3, [r0, #20]
57bc: e3130c01 tst r3, #256 ; 0x100
57c0: 0a00000f beq 5804 <ioctl+0x74>
/*
* Now process the ioctl().
*/
if ( !iop->handlers )
57c4: e590303c ldr r3, [r0, #60] ; 0x3c
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
va_start(ap, command);
buffer = va_arg(ap, void *);
57c8: e28d2010 add r2, sp, #16
/*
* Now process the ioctl().
*/
if ( !iop->handlers )
57cc: e3530000 cmp r3, #0
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
va_start(ap, command);
buffer = va_arg(ap, void *);
57d0: e58d2000 str r2, [sp]
57d4: e59d200c ldr r2, [sp, #12]
/*
* Now process the ioctl().
*/
if ( !iop->handlers )
57d8: 0a000009 beq 5804 <ioctl+0x74>
rtems_set_errno_and_return_minus_one( EBADF );
if ( !iop->handlers->ioctl_h )
57dc: e5933010 ldr r3, [r3, #16]
57e0: e3530000 cmp r3, #0
57e4: 0a00000b beq 5818 <ioctl+0x88>
rtems_set_errno_and_return_minus_one( ENOTSUP );
rc = (*iop->handlers->ioctl_h)( iop, command, buffer );
57e8: e59d1008 ldr r1, [sp, #8]
57ec: e1a0e00f mov lr, pc
57f0: e12fff13 bx r3
return rc;
}
57f4: e28dd004 add sp, sp, #4
57f8: e49de004 pop {lr} ; (ldr lr, [sp], #4)
57fc: e28dd00c add sp, sp, #12
5800: e12fff1e bx lr
/*
* Now process the ioctl().
*/
if ( !iop->handlers )
rtems_set_errno_and_return_minus_one( EBADF );
5804: eb003370 bl 125cc <__errno>
5808: e3a03009 mov r3, #9
580c: e5803000 str r3, [r0]
5810: e3e00000 mvn r0, #0
5814: eafffff6 b 57f4 <ioctl+0x64>
if ( !iop->handlers->ioctl_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
5818: eb00336b bl 125cc <__errno> <== NOT EXECUTED
581c: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
5820: e5803000 str r3, [r0] <== NOT EXECUTED
5824: e3e00000 mvn r0, #0 <== NOT EXECUTED
5828: eafffff1 b 57f4 <ioctl+0x64> <== NOT EXECUTED
00003b30 <iproc>:
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
if (tty->termios.c_iflag & ISTRIP)
3b30: e5913030 ldr r3, [r1, #48] ; 0x30 <== NOT EXECUTED
3b34: e3130020 tst r3, #32 <== NOT EXECUTED
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
3b38: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3b3c: e20040ff and r4, r0, #255 ; 0xff <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP) c &= 0x7f;
3b40: 1200407f andne r4, r0, #127 ; 0x7f <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
3b44: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
/*
* Process a single input character
*/
static int
iproc (unsigned char c, struct rtems_termios_tty *tty)
{
3b48: e1a05001 mov r5, r1 <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP) c &= 0x7f; if (tty->termios.c_iflag & IUCLC)
3b4c: 0a000007 beq 3b70 <iproc+0x40> <== NOT EXECUTED
c = tolower (c);
3b50: e59f2198 ldr r2, [pc, #408] ; 3cf0 <iproc+0x1c0> <== NOT EXECUTED
3b54: e5922000 ldr r2, [r2] <== NOT EXECUTED
3b58: e0822004 add r2, r2, r4 <== NOT EXECUTED
3b5c: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED
3b60: e2022003 and r2, r2, #3 <== NOT EXECUTED
3b64: e3520001 cmp r2, #1 <== NOT EXECUTED
3b68: 02844020 addeq r4, r4, #32 <== NOT EXECUTED
3b6c: e20440ff and r4, r4, #255 ; 0xff <== NOT EXECUTED
if (c == '\r') {
3b70: e354000d cmp r4, #13 <== NOT EXECUTED
3b74: 0a000012 beq 3bc4 <iproc+0x94> <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
}
else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
3b78: e354000a cmp r4, #10 <== NOT EXECUTED
3b7c: 0a000034 beq 3c54 <iproc+0x124> <== NOT EXECUTED
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
3b80: e3540000 cmp r4, #0 <== NOT EXECUTED
3b84: 1a000015 bne 3be0 <iproc+0xb0> <== NOT EXECUTED
}
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
3b88: e59f3164 ldr r3, [pc, #356] ; 3cf4 <iproc+0x1c4> <== NOT EXECUTED
3b8c: e5932000 ldr r2, [r3] <== NOT EXECUTED
3b90: e5953020 ldr r3, [r5, #32] <== NOT EXECUTED
3b94: e2422001 sub r2, r2, #1 <== NOT EXECUTED
3b98: e1530002 cmp r3, r2 <== NOT EXECUTED
3b9c: aa00000a bge 3bcc <iproc+0x9c> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
3ba0: e595203c ldr r2, [r5, #60] ; 0x3c <== NOT EXECUTED
3ba4: e3120008 tst r2, #8 <== NOT EXECUTED
3ba8: 1a00002c bne 3c60 <iproc+0x130> <== NOT EXECUTED
echo (c, tty); tty->cbuf[tty->ccount++] = c;
3bac: e595101c ldr r1, [r5, #28] <== NOT EXECUTED
3bb0: e2832001 add r2, r3, #1 <== NOT EXECUTED
3bb4: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
3bb8: e3a00000 mov r0, #0 <== NOT EXECUTED
3bbc: e5852020 str r2, [r5, #32] <== NOT EXECUTED
3bc0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (tty->termios.c_iflag & ISTRIP)
c &= 0x7f;
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
3bc4: e3130080 tst r3, #128 ; 0x80 <== NOT EXECUTED
3bc8: 0a000001 beq 3bd4 <iproc+0xa4> <== NOT EXECUTED
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
tty->cbuf[tty->ccount++] = c;
3bcc: e3a00000 mov r0, #0 <== NOT EXECUTED
} return 0; }
3bd0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (tty->termios.c_iflag & IUCLC)
c = tolower (c);
if (c == '\r') {
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
3bd4: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED
3bd8: 03a0400d moveq r4, #13 <== NOT EXECUTED
3bdc: 13a0400a movne r4, #10 <== NOT EXECUTED
c = '\n';
}
else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
3be0: e595303c ldr r3, [r5, #60] ; 0x3c <== NOT EXECUTED
3be4: e3130002 tst r3, #2 <== NOT EXECUTED
3be8: 0affffe6 beq 3b88 <iproc+0x58> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
3bec: e5d52043 ldrb r2, [r5, #67] ; 0x43 <== NOT EXECUTED
3bf0: e1520004 cmp r2, r4 <== NOT EXECUTED
3bf4: 0a000038 beq 3cdc <iproc+0x1ac> <== NOT EXECUTED
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
3bf8: e5d52044 ldrb r2, [r5, #68] ; 0x44 <== NOT EXECUTED
3bfc: e1520004 cmp r2, r4 <== NOT EXECUTED
3c00: 0a000030 beq 3cc8 <iproc+0x198> <== NOT EXECUTED
erase (tty, 1);
return 0;
}
else if (c == tty->termios.c_cc[VEOF]) {
3c04: e5d52045 ldrb r2, [r5, #69] ; 0x45 <== NOT EXECUTED
3c08: e1520004 cmp r2, r4 <== NOT EXECUTED
3c0c: 0a000027 beq 3cb0 <iproc+0x180> <== NOT EXECUTED
return 1;
}
else if (c == '\n') {
3c10: e354000a cmp r4, #10 <== NOT EXECUTED
3c14: 0a00001b beq 3c88 <iproc+0x158> <== NOT EXECUTED
if (tty->termios.c_lflag & (ECHO | ECHONL)) echo (c, tty); tty->cbuf[tty->ccount++] = c; return 1; } else if ((c == tty->termios.c_cc[VEOL])
3c18: e5d5204c ldrb r2, [r5, #76] ; 0x4c <== NOT EXECUTED
3c1c: e1520004 cmp r2, r4 <== NOT EXECUTED
3c20: 0a000002 beq 3c30 <iproc+0x100> <== NOT EXECUTED
|| (c == tty->termios.c_cc[VEOL2])) {
3c24: e5d52051 ldrb r2, [r5, #81] ; 0x51 <== NOT EXECUTED
3c28: e1520004 cmp r2, r4 <== NOT EXECUTED
3c2c: 1affffd5 bne 3b88 <iproc+0x58> <== NOT EXECUTED
if (tty->termios.c_lflag & ECHO)
3c30: e3130008 tst r3, #8 <== NOT EXECUTED
3c34: 1a00001f bne 3cb8 <iproc+0x188> <== NOT EXECUTED
echo (c, tty); tty->cbuf[tty->ccount++] = c;
3c38: e285101c add r1, r5, #28 <== NOT EXECUTED
3c3c: e891000a ldm r1, {r1, r3} <== NOT EXECUTED
3c40: e2832001 add r2, r3, #1 <== NOT EXECUTED
3c44: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
3c48: e3a00001 mov r0, #1 <== NOT EXECUTED
3c4c: e5852020 str r2, [r5, #32] <== NOT EXECUTED
return 1;
3c50: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (tty->termios.c_iflag & IGNCR)
return 0;
if (tty->termios.c_iflag & ICRNL)
c = '\n';
}
else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
3c54: e3130040 tst r3, #64 ; 0x40 <== NOT EXECUTED
3c58: 13a0400d movne r4, #13 <== NOT EXECUTED
3c5c: eaffffdf b 3be0 <iproc+0xb0> <== NOT EXECUTED
/*
* FIXME: Should do IMAXBEL handling somehow
*/
if (tty->ccount < (CBUFSIZE-1)) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
3c60: e1a00004 mov r0, r4 <== NOT EXECUTED
3c64: e1a01005 mov r1, r5 <== NOT EXECUTED
3c68: ebffff0b bl 389c <echo> <== NOT EXECUTED
3c6c: e285101c add r1, r5, #28 <== NOT EXECUTED
3c70: e891000a ldm r1, {r1, r3} <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
3c74: e2832001 add r2, r3, #1 <== NOT EXECUTED
3c78: e7c14003 strb r4, [r1, r3] <== NOT EXECUTED
3c7c: e3a00000 mov r0, #0 <== NOT EXECUTED
3c80: e5852020 str r2, [r5, #32] <== NOT EXECUTED
3c84: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
}
else if (c == tty->termios.c_cc[VEOF]) {
return 1;
}
else if (c == '\n') {
if (tty->termios.c_lflag & (ECHO | ECHONL))
3c88: e3130048 tst r3, #72 ; 0x48 <== NOT EXECUTED
echo (c, tty);
3c8c: 11a00004 movne r0, r4 <== NOT EXECUTED
3c90: 11a01005 movne r1, r5 <== NOT EXECUTED
3c94: 1bffff00 blne 389c <echo> <== NOT EXECUTED
tty->cbuf[tty->ccount++] = c;
3c98: e285101c add r1, r5, #28 <== NOT EXECUTED
3c9c: e891000a ldm r1, {r1, r3} <== NOT EXECUTED
3ca0: e2832001 add r2, r3, #1 <== NOT EXECUTED
3ca4: e3a0000a mov r0, #10 <== NOT EXECUTED
3ca8: e7c10003 strb r0, [r1, r3] <== NOT EXECUTED
3cac: e5852020 str r2, [r5, #32] <== NOT EXECUTED
3cb0: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
3cb4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
}
else if ((c == tty->termios.c_cc[VEOL])
|| (c == tty->termios.c_cc[VEOL2])) {
if (tty->termios.c_lflag & ECHO)
echo (c, tty);
3cb8: e1a00004 mov r0, r4 <== NOT EXECUTED
3cbc: e1a01005 mov r1, r5 <== NOT EXECUTED
3cc0: ebfffef5 bl 389c <echo> <== NOT EXECUTED
3cc4: eaffffdb b 3c38 <iproc+0x108> <== NOT EXECUTED
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
return 0;
}
else if (c == tty->termios.c_cc[VKILL]) {
erase (tty, 1);
3cc8: e1a00005 mov r0, r5 <== NOT EXECUTED
3ccc: e3a01001 mov r1, #1 <== NOT EXECUTED
3cd0: ebffff13 bl 3924 <erase> <== NOT EXECUTED
3cd4: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
3cd8: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
else if ((c == '\n') && (tty->termios.c_iflag & INLCR)) {
c = '\r';
}
if ((c != '\0') && (tty->termios.c_lflag & ICANON)) {
if (c == tty->termios.c_cc[VERASE]) {
erase (tty, 0);
3cdc: e1a00005 mov r0, r5 <== NOT EXECUTED
3ce0: e3a01000 mov r1, #0 <== NOT EXECUTED
3ce4: ebffff0e bl 3924 <erase> <== NOT EXECUTED
3ce8: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
3cec: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
0002206c <kill>:
#if !defined(RTEMS_POSIX_API)
int kill( pid_t pid, int sig )
{
return 0;
}
2206c: e3a00000 mov r0, #0 <== NOT EXECUTED 22070: e12fff1e bx lr <== NOT EXECUTED
00029b9c <link>:
int link(
const char *existing,
const char *new
)
{
29b9c: e92d4070 push {r4, r5, r6, lr}
29ba0: e24dd034 sub sp, sp, #52 ; 0x34
29ba4: e1a05001 mov r5, r1
29ba8: e1a06000 mov r6, r0
/*
* Get the node we are linking to.
*/
result = rtems_filesystem_evaluate_path( existing, strlen( existing ),
29bac: eb00800c bl 49be4 <strlen> 29bb0: e28d4018 add r4, sp, #24 29bb4: e1a01000 mov r1, r0 29bb8: e3a0c001 mov ip, #1 29bbc: e1a00006 mov r0, r6 29bc0: e3a02000 mov r2, #0 29bc4: e1a03004 mov r3, r4 29bc8: e58dc000 str ip, [sp] 29bcc: ebff7845 bl 7ce8 <rtems_filesystem_evaluate_path>
0, &existing_loc, true );
if ( result != 0 )
29bd0: e3500000 cmp r0, #0
29bd4: 0a000003 beq 29be8 <link+0x4c>
rtems_filesystem_get_start_loc( new, &i, &parent_loc );
if ( !parent_loc.ops->evalformake_h ) {
rtems_filesystem_freenode( &existing_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
29bd8: e3e05000 mvn r5, #0
rtems_filesystem_freenode( &existing_loc );
rtems_filesystem_freenode( &parent_loc );
return result;
}
29bdc: e1a00005 mov r0, r5
29be0: e28dd034 add sp, sp, #52 ; 0x34
29be4: e8bd8070 pop {r4, r5, r6, pc}
/*
* Get the parent of the node we are creating.
*/
rtems_filesystem_get_start_loc( new, &i, &parent_loc );
29be8: e28d6004 add r6, sp, #4 29bec: e1a00005 mov r0, r5 29bf0: e28d1030 add r1, sp, #48 ; 0x30 29bf4: e1a02006 mov r2, r6 29bf8: ebff7ecb bl 972c <rtems_filesystem_get_start_loc>
if ( !parent_loc.ops->evalformake_h ) {
29bfc: e59d3010 ldr r3, [sp, #16] 29c00: e5933004 ldr r3, [r3, #4] 29c04: e3530000 cmp r3, #0
29c08: 0a000048 beq 29d30 <link+0x194>
rtems_filesystem_freenode( &existing_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
29c0c: e59d0030 ldr r0, [sp, #48] ; 0x30 29c10: e1a01006 mov r1, r6 29c14: e0850000 add r0, r5, r0 29c18: e28d202c add r2, sp, #44 ; 0x2c 29c1c: e1a0e00f mov lr, pc 29c20: e12fff13 bx r3
if ( result != 0 ) {
29c24: e2505000 subs r5, r0, #0
29c28: 1a000034 bne 29d00 <link+0x164>
/*
* Check to see if the caller is trying to link across file system
* boundaries.
*/
if ( parent_loc.mt_entry != existing_loc.mt_entry ) {
29c2c: e59d3028 ldr r3, [sp, #40] ; 0x28 29c30: e59d2014 ldr r2, [sp, #20] 29c34: e1520003 cmp r2, r3
29c38: 1a00001b bne 29cac <link+0x110>
rtems_filesystem_freenode( &existing_loc );
rtems_filesystem_freenode( &parent_loc );
rtems_set_errno_and_return_minus_one( EXDEV );
}
if ( !parent_loc.ops->link_h ) {
29c3c: e59d2010 ldr r2, [sp, #16] 29c40: e5923008 ldr r3, [r2, #8] 29c44: e3530000 cmp r3, #0
29c48: 0a000044 beq 29d60 <link+0x1c4>
rtems_filesystem_freenode( &existing_loc );
rtems_filesystem_freenode( &parent_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start );
29c4c: e1a00004 mov r0, r4 29c50: e1a01006 mov r1, r6 29c54: e59d202c ldr r2, [sp, #44] ; 0x2c 29c58: e1a0e00f mov lr, pc 29c5c: e12fff13 bx r3
rtems_filesystem_freenode( &existing_loc );
29c60: e59d3024 ldr r3, [sp, #36] ; 0x24 29c64: e3530000 cmp r3, #0
rtems_filesystem_freenode( &existing_loc );
rtems_filesystem_freenode( &parent_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*parent_loc.ops->link_h)( &existing_loc, &parent_loc, name_start );
29c68: e1a05000 mov r5, r0
rtems_filesystem_freenode( &existing_loc );
29c6c: 0a000004 beq 29c84 <link+0xe8>
29c70: e593301c ldr r3, [r3, #28] 29c74: e3530000 cmp r3, #0 29c78: 11a00004 movne r0, r4 29c7c: 11a0e00f movne lr, pc 29c80: 112fff13 bxne r3
rtems_filesystem_freenode( &parent_loc );
29c84: e59d3010 ldr r3, [sp, #16] 29c88: e3530000 cmp r3, #0
29c8c: 0affffd2 beq 29bdc <link+0x40>
29c90: e593301c ldr r3, [r3, #28] 29c94: e3530000 cmp r3, #0
29c98: 0affffcf beq 29bdc <link+0x40>
29c9c: e1a00006 mov r0, r6 29ca0: e1a0e00f mov lr, pc 29ca4: e12fff13 bx r3 29ca8: eaffffcb b 29bdc <link+0x40>
* Check to see if the caller is trying to link across file system
* boundaries.
*/
if ( parent_loc.mt_entry != existing_loc.mt_entry ) {
rtems_filesystem_freenode( &existing_loc );
29cac: e59d3024 ldr r3, [sp, #36] ; 0x24 29cb0: e3530000 cmp r3, #0
29cb4: 0a000004 beq 29ccc <link+0x130>
29cb8: e593301c ldr r3, [r3, #28] 29cbc: e3530000 cmp r3, #0 29cc0: 11a00004 movne r0, r4 29cc4: 11a0e00f movne lr, pc 29cc8: 112fff13 bxne r3
rtems_filesystem_freenode( &parent_loc );
29ccc: e59d3010 ldr r3, [sp, #16] 29cd0: e3530000 cmp r3, #0
29cd4: 0a000004 beq 29cec <link+0x150>
29cd8: e593301c ldr r3, [r3, #28] 29cdc: e3530000 cmp r3, #0 29ce0: 11a00006 movne r0, r6 29ce4: 11a0e00f movne lr, pc 29ce8: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( EXDEV );
29cec: eb0064bf bl 42ff0 <__errno> 29cf0: e3a03012 mov r3, #18 29cf4: e5803000 str r3, [r0] 29cf8: e3e05000 mvn r5, #0 29cfc: eaffffb6 b 29bdc <link+0x40>
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*parent_loc.ops->evalformake_h)( &new[i], &parent_loc, &name_start );
if ( result != 0 ) {
rtems_filesystem_freenode( &existing_loc );
29d00: e59d3024 ldr r3, [sp, #36] ; 0x24 29d04: e3530000 cmp r3, #0
29d08: 0a000004 beq 29d20 <link+0x184>
29d0c: e593301c ldr r3, [r3, #28] 29d10: e3530000 cmp r3, #0 29d14: 11a00004 movne r0, r4 29d18: 11a0e00f movne lr, pc 29d1c: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( result );
29d20: eb0064b2 bl 42ff0 <__errno> 29d24: e5805000 str r5, [r0] 29d28: e3e05000 mvn r5, #0 29d2c: eaffffaa b 29bdc <link+0x40>
*/
rtems_filesystem_get_start_loc( new, &i, &parent_loc );
if ( !parent_loc.ops->evalformake_h ) {
rtems_filesystem_freenode( &existing_loc );
29d30: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 29d34: e3530000 cmp r3, #0 <== NOT EXECUTED 29d38: 0a000004 beq 29d50 <link+0x1b4> <== NOT EXECUTED 29d3c: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 29d40: e3530000 cmp r3, #0 <== NOT EXECUTED 29d44: 11a00004 movne r0, r4 <== NOT EXECUTED 29d48: 11a0e00f movne lr, pc <== NOT EXECUTED 29d4c: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
29d50: eb0064a6 bl 42ff0 <__errno> <== NOT EXECUTED 29d54: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 29d58: e5803000 str r3, [r0] <== NOT EXECUTED 29d5c: eaffff9d b 29bd8 <link+0x3c> <== NOT EXECUTED
rtems_filesystem_freenode( &parent_loc );
rtems_set_errno_and_return_minus_one( EXDEV );
}
if ( !parent_loc.ops->link_h ) {
rtems_filesystem_freenode( &existing_loc );
29d60: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 29d64: e3530000 cmp r3, #0 <== NOT EXECUTED 29d68: 0a000006 beq 29d88 <link+0x1ec> <== NOT EXECUTED 29d6c: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 29d70: e3530000 cmp r3, #0 <== NOT EXECUTED 29d74: 0a000003 beq 29d88 <link+0x1ec> <== NOT EXECUTED 29d78: e1a00004 mov r0, r4 <== NOT EXECUTED 29d7c: e1a0e00f mov lr, pc <== NOT EXECUTED 29d80: e12fff13 bx r3 <== NOT EXECUTED 29d84: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED
rtems_filesystem_freenode( &parent_loc );
29d88: e3520000 cmp r2, #0 <== NOT EXECUTED 29d8c: 0a000004 beq 29da4 <link+0x208> <== NOT EXECUTED 29d90: e592301c ldr r3, [r2, #28] <== NOT EXECUTED 29d94: e3530000 cmp r3, #0 <== NOT EXECUTED 29d98: 11a00006 movne r0, r6 <== NOT EXECUTED 29d9c: 11a0e00f movne lr, pc <== NOT EXECUTED 29da0: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
29da4: eb006491 bl 42ff0 <__errno> <== NOT EXECUTED 29da8: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 29dac: e5803000 str r3, [r0] <== NOT EXECUTED 29db0: e3e05000 mvn r5, #0 <== NOT EXECUTED 29db4: eaffff88 b 29bdc <link+0x40> <== NOT EXECUTED
00019bb0 <lseek>:
{
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
19bb0: e59fc134 ldr ip, [pc, #308] ; 19cec <lseek+0x13c> 19bb4: e59cc000 ldr ip, [ip] 19bb8: e150000c cmp r0, ip
off_t lseek(
int fd,
off_t offset,
int whence
)
{
19bbc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
rtems_libio_t *iop;
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
19bc0: 2a00003d bcs 19cbc <lseek+0x10c>
iop = rtems_libio_iop( fd );
19bc4: e59fc124 ldr ip, [pc, #292] ; 19cf0 <lseek+0x140> 19bc8: e59c4000 ldr r4, [ip] 19bcc: e0844300 add r4, r4, r0, lsl #6
rtems_libio_check_is_open(iop);
19bd0: e5940014 ldr r0, [r4, #20] 19bd4: e3100c01 tst r0, #256 ; 0x100
19bd8: 0a000037 beq 19cbc <lseek+0x10c>
/*
* Check as many errors as possible before touching iop->offset.
*/
if ( !iop->handlers->lseek_h )
19bdc: e594c03c ldr ip, [r4, #60] ; 0x3c 19be0: e59c0014 ldr r0, [ip, #20] 19be4: e3500000 cmp r0, #0
19be8: 0a000039 beq 19cd4 <lseek+0x124>
/*
* Now process the lseek().
*/
old_offset = iop->offset;
switch ( whence ) {
19bec: e3530001 cmp r3, #1
/*
* Now process the lseek().
*/
old_offset = iop->offset;
19bf0: e284600c add r6, r4, #12
19bf4: e8960060 ldm r6, {r5, r6}
switch ( whence ) {
19bf8: 0a00002a beq 19ca8 <lseek+0xf8>
19bfc: e3530002 cmp r3, #2
19c00: 0a00000d beq 19c3c <lseek+0x8c>
19c04: e3530000 cmp r3, #0
19c08: 1a00001e bne 19c88 <lseek+0xd8>
case SEEK_SET:
iop->offset = offset;
19c0c: e584100c str r1, [r4, #12] 19c10: e5842010 str r2, [r4, #16]
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->handlers->lseek_h)( iop, offset, whence );
19c14: e1a00004 mov r0, r4 19c18: e1a0e00f mov lr, pc 19c1c: e59cf014 ldr pc, [ip, #20]
if ( status == (off_t) -1 )
19c20: e3700001 cmn r0, #1
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->handlers->lseek_h)( iop, offset, whence );
19c24: e1a02000 mov r2, r0 19c28: e1a03001 mov r3, r1
if ( status == (off_t) -1 )
19c2c: 0a00000e beq 19c6c <lseek+0xbc>
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
19c30: e1a01003 mov r1, r3
19c34: e1a00002 mov r0, r2
19c38: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
case SEEK_CUR:
iop->offset += offset;
break;
case SEEK_END:
iop->offset = iop->size + offset;
19c3c: e9940180 ldmib r4, {r7, r8}
19c40: e0977001 adds r7, r7, r1
19c44: e0a88002 adc r8, r8, r2
19c48: e584700c str r7, [r4, #12]
19c4c: e5848010 str r8, [r4, #16]
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->handlers->lseek_h)( iop, offset, whence );
19c50: e1a00004 mov r0, r4 19c54: e1a0e00f mov lr, pc 19c58: e59cf014 ldr pc, [ip, #20]
if ( status == (off_t) -1 )
19c5c: e3700001 cmn r0, #1
/*
* At this time, handlers assume iop->offset has the desired
* new offset.
*/
status = (*iop->handlers->lseek_h)( iop, offset, whence );
19c60: e1a02000 mov r2, r0 19c64: e1a03001 mov r3, r1
if ( status == (off_t) -1 ) 19c68: 1afffff0 bne 19c30 <lseek+0x80>
19c6c: e3710001 cmn r1, #1
19c70: 1affffee bne 19c30 <lseek+0x80>
iop->offset = old_offset;
19c74: e584500c str r5, [r4, #12] 19c78: e5846010 str r6, [r4, #16]
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
19c7c: e1a01003 mov r1, r3
19c80: e1a00002 mov r0, r2
19c84: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
case SEEK_END:
iop->offset = iop->size + offset;
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
19c88: ebffd18c bl e2c0 <__errno> 19c8c: e3a03016 mov r3, #22 19c90: e5803000 str r3, [r0] 19c94: e3e02000 mvn r2, #0 19c98: e3e03000 mvn r3, #0
/*
* So if the operation failed, we have to restore iop->offset.
*/
return status;
}
19c9c: e1a01003 mov r1, r3
19ca0: e1a00002 mov r0, r2
19ca4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
case SEEK_SET:
iop->offset = offset;
break;
case SEEK_CUR:
iop->offset += offset;
19ca8: e0917005 adds r7, r1, r5 19cac: e0a28006 adc r8, r2, r6 19cb0: e584700c str r7, [r4, #12] 19cb4: e5848010 str r8, [r4, #16]
break;
19cb8: eaffffd5 b 19c14 <lseek+0x64>
off_t old_offset;
off_t status;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open(iop);
19cbc: ebffd17f bl e2c0 <__errno> <== NOT EXECUTED 19cc0: e3a03009 mov r3, #9 <== NOT EXECUTED 19cc4: e5803000 str r3, [r0] <== NOT EXECUTED 19cc8: e3e02000 mvn r2, #0 <== NOT EXECUTED 19ccc: e3e03000 mvn r3, #0 <== NOT EXECUTED 19cd0: eaffffd6 b 19c30 <lseek+0x80> <== NOT EXECUTED
/*
* Check as many errors as possible before touching iop->offset.
*/
if ( !iop->handlers->lseek_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
19cd4: ebffd179 bl e2c0 <__errno> <== NOT EXECUTED 19cd8: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 19cdc: e5803000 str r3, [r0] <== NOT EXECUTED 19ce0: e3e02000 mvn r2, #0 <== NOT EXECUTED 19ce4: e3e03000 mvn r3, #0 <== NOT EXECUTED 19ce8: eaffffd0 b 19c30 <lseek+0x80> <== NOT EXECUTED
00029f1c <lstat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
29f1c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
29f20: e2515000 subs r5, r1, #0 <== NOT EXECUTED
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
29f24: e24dd018 sub sp, sp, #24 <== NOT EXECUTED 29f28: e1a06000 mov r6, r0 <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
29f2c: 0a00002f beq 29ff0 <lstat+0xd4> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
29f30: eb007f2b bl 49be4 <strlen> <== NOT EXECUTED 29f34: e28d4004 add r4, sp, #4 <== NOT EXECUTED 29f38: e3a0c000 mov ip, #0 <== NOT EXECUTED 29f3c: e1a01000 mov r1, r0 <== NOT EXECUTED 29f40: e1a0200c mov r2, ip <== NOT EXECUTED 29f44: e1a00006 mov r0, r6 <== NOT EXECUTED 29f48: e1a03004 mov r3, r4 <== NOT EXECUTED 29f4c: e58dc000 str ip, [sp] <== NOT EXECUTED 29f50: ebff7764 bl 7ce8 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
29f54: e2501000 subs r1, r0, #0 <== NOT EXECUTED 29f58: 1a000022 bne 29fe8 <lstat+0xcc> <== NOT EXECUTED
return -1;
if ( !loc.handlers->fstat_h ){
29f5c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 29f60: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED 29f64: e3530000 cmp r3, #0 <== NOT EXECUTED 29f68: 0a000013 beq 29fbc <lstat+0xa0> <== NOT EXECUTED
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
29f6c: e3a02048 mov r2, #72 ; 0x48 <== NOT EXECUTED 29f70: e1a00005 mov r0, r5 <== NOT EXECUTED 29f74: eb007154 bl 464cc <memset> <== NOT EXECUTED
status = (*loc.handlers->fstat_h)( &loc, buf );
29f78: e1a01005 mov r1, r5 <== NOT EXECUTED 29f7c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 29f80: e1a00004 mov r0, r4 <== NOT EXECUTED 29f84: e1a0e00f mov lr, pc <== NOT EXECUTED 29f88: e593f018 ldr pc, [r3, #24] <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
29f8c: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 29f90: e3530000 cmp r3, #0 <== NOT EXECUTED
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
status = (*loc.handlers->fstat_h)( &loc, buf );
29f94: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
29f98: 0a000004 beq 29fb0 <lstat+0x94> <== NOT EXECUTED 29f9c: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 29fa0: e3530000 cmp r3, #0 <== NOT EXECUTED 29fa4: 11a00004 movne r0, r4 <== NOT EXECUTED 29fa8: 11a0e00f movne lr, pc <== NOT EXECUTED 29fac: 112fff13 bxne r3 <== NOT EXECUTED
return status;
}
29fb0: e1a00005 mov r0, r5 <== NOT EXECUTED
29fb4: e28dd018 add sp, sp, #24 <== NOT EXECUTED
29fb8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
return -1;
if ( !loc.handlers->fstat_h ){
rtems_filesystem_freenode( &loc );
29fbc: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 29fc0: e3530000 cmp r3, #0 <== NOT EXECUTED 29fc4: 0a000004 beq 29fdc <lstat+0xc0> <== NOT EXECUTED 29fc8: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 29fcc: e3530000 cmp r3, #0 <== NOT EXECUTED 29fd0: 11a00004 movne r0, r4 <== NOT EXECUTED 29fd4: 11a0e00f movne lr, pc <== NOT EXECUTED 29fd8: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
29fdc: eb006403 bl 42ff0 <__errno> <== NOT EXECUTED 29fe0: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 29fe4: e5803000 str r3, [r0] <== NOT EXECUTED 29fe8: e3e05000 mvn r5, #0 <== NOT EXECUTED 29fec: eaffffef b 29fb0 <lstat+0x94> <== NOT EXECUTED
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
rtems_set_errno_and_return_minus_one( EFAULT );
29ff0: eb0063fe bl 42ff0 <__errno> <== NOT EXECUTED 29ff4: e3a0300e mov r3, #14 <== NOT EXECUTED 29ff8: e5803000 str r3, [r0] <== NOT EXECUTED 29ffc: e3e05000 mvn r5, #0 <== NOT EXECUTED 2a000: eaffffea b 29fb0 <lstat+0x94> <== NOT EXECUTED
0000240c <malloc>:
size_t size
)
{
void *return_this;
MSBUMP(malloc_calls, 1);
240c: e59f30dc ldr r3, [pc, #220] ; 24f0 <malloc+0xe4>
2410: e5932004 ldr r2, [r3, #4]
2414: e2822001 add r2, r2, #1
2418: e92d4070 push {r4, r5, r6, lr}
241c: e5832004 str r2, [r3, #4]
2420: e1a04000 mov r4, r0
/*
* If some free's have been deferred, then do them now.
*/
malloc_deferred_frees_process();
2424: ebffffb3 bl 22f8 <malloc_deferred_frees_process>
/*
* Validate the parameters
*/
if ( !size )
2428: e3540000 cmp r4, #0
242c: 0a00001f beq 24b0 <malloc+0xa4>
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
2430: e59f30bc ldr r3, [pc, #188] ; 24f4 <malloc+0xe8>
2434: e5933000 ldr r3, [r3]
2438: e3530003 cmp r3, #3
243c: 0a000018 beq 24a4 <malloc+0x98>
RTEMS_INLINE_ROUTINE void *_Protected_heap_Allocate(
Heap_Control *heap,
uintptr_t size
)
{
return _Protected_heap_Allocate_aligned_with_boundary( heap, size, 0, 0 );
2440: e59f30b0 ldr r3, [pc, #176] ; 24f8 <malloc+0xec>
2444: e3a02000 mov r2, #0
2448: e5930000 ldr r0, [r3]
244c: e1a01004 mov r1, r4
2450: e1a03002 mov r3, r2
2454: eb00135a bl 71c4 <_Protected_heap_Allocate_aligned_with_boundary>
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
2458: e2506000 subs r6, r0, #0
if (rtems_malloc_sbrk_helpers)
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
if ( !return_this ) {
errno = ENOMEM;
return (void *) 0;
245c: 11a05006 movne r5, r6
* If this fails then return a NULL pointer.
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
2460: 0a000015 beq 24bc <malloc+0xb0>
}
/*
* If the user wants us to dirty the allocated memory, then do it.
*/
if ( rtems_malloc_dirty_helper )
2464: e59f3090 ldr r3, [pc, #144] ; 24fc <malloc+0xf0>
2468: e5933000 ldr r3, [r3]
246c: e3530000 cmp r3, #0
(*rtems_malloc_dirty_helper)( return_this, size );
2470: 11a01004 movne r1, r4
2474: 11a00005 movne r0, r5
2478: 11a0e00f movne lr, pc
247c: 112fff13 bxne r3
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
2480: e59f3078 ldr r3, [pc, #120] ; 2500 <malloc+0xf4>
2484: e5933000 ldr r3, [r3]
2488: e3530000 cmp r3, #0
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
248c: 11a00005 movne r0, r5
2490: 11a0e00f movne lr, pc
2494: 1593f004 ldrne pc, [r3, #4]
2498: e1a06005 mov r6, r5
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
return return_this;
}
249c: e1a00006 mov r0, r6
24a0: e8bd8070 pop {r4, r5, r6, pc}
return (void *) 0;
/*
* Do not attempt to allocate memory if not in correct system state.
*/
if ( _System_state_Is_up(_System_state_Get()) &&
24a4: ebffff7c bl 229c <malloc_is_system_state_OK>
24a8: e3500000 cmp r0, #0
24ac: 1affffe3 bne 2440 <malloc+0x34>
/*
* If configured, update the statistics
*/
if ( rtems_malloc_statistics_helpers )
(*rtems_malloc_statistics_helpers->at_malloc)(return_this);
24b0: e3a06000 mov r6, #0 <== NOT EXECUTED
if (rtems_malloc_boundary_helpers)
(*rtems_malloc_boundary_helpers->at_malloc)(return_this, size);
#endif
return return_this;
}
24b4: e1a00006 mov r0, r6 <== NOT EXECUTED
24b8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
*/
return_this = _Protected_heap_Allocate( RTEMS_Malloc_Heap, size );
if ( !return_this ) {
if (rtems_malloc_sbrk_helpers)
24bc: e59f3040 ldr r3, [pc, #64] ; 2504 <malloc+0xf8>
24c0: e5933000 ldr r3, [r3]
24c4: e3530000 cmp r3, #0
24c8: 0a000004 beq 24e0 <malloc+0xd4>
return_this = (*rtems_malloc_sbrk_helpers->extend)( size );
24cc: e1a00004 mov r0, r4 <== NOT EXECUTED
24d0: e1a0e00f mov lr, pc <== NOT EXECUTED
24d4: e593f004 ldr pc, [r3, #4] <== NOT EXECUTED
if ( !return_this ) {
24d8: e2505000 subs r5, r0, #0 <== NOT EXECUTED
24dc: 1affffe0 bne 2464 <malloc+0x58> <== NOT EXECUTED
errno = ENOMEM;
24e0: eb002f76 bl e2c0 <__errno>
24e4: e3a0300c mov r3, #12
24e8: e5803000 str r3, [r0]
return (void *) 0;
24ec: eaffffea b 249c <malloc+0x90>
000022e8 <malloc_deferred_free>:
}
void malloc_deferred_free(
void *pointer
)
{
22e8: e1a01000 mov r1, r0 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
22ec: e59f0000 ldr r0, [pc, #0] ; 22f4 <malloc_deferred_free+0xc><== NOT EXECUTED
22f0: ea000f71 b 60bc <_Chain_Append> <== NOT EXECUTED
000022f8 <malloc_deferred_frees_process>:
{
rtems_chain_initialize_empty(&RTEMS_Malloc_GC_list);
}
void malloc_deferred_frees_process(void)
{
22f8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_chain_node *to_be_freed;
/*
* If some free's have been deferred, then do them now.
*/
while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
22fc: ea000000 b 2304 <malloc_deferred_frees_process+0xc>
free(to_be_freed);
2300: ebffff68 bl 20a8 <free> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
2304: e59f000c ldr r0, [pc, #12] ; 2318 <malloc_deferred_frees_process+0x20>
2308: eb000f7f bl 610c <_Chain_Get>
rtems_chain_node *to_be_freed;
/*
* If some free's have been deferred, then do them now.
*/
while ((to_be_freed = rtems_chain_get(&RTEMS_Malloc_GC_list)) != NULL)
230c: e3500000 cmp r0, #0
2310: 1afffffa bne 2300 <malloc_deferred_frees_process+0x8>
free(to_be_freed);
}
2314: e49df004 pop {pc} ; (ldr pc, [sp], #4)
0000c638 <memfile_free_blocks_in_table>:
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
c638: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
/*
* Perform internal consistency checks
*/
assert( block_table );
c63c: e2504000 subs r4, r0, #0
void memfile_free_blocks_in_table(
block_p **block_table,
int entries
)
{
c640: e1a08001 mov r8, r1
/*
* Perform internal consistency checks
*/
assert( block_table );
c644: 0a000014 beq c69c <memfile_free_blocks_in_table+0x64>
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
c648: e3510000 cmp r1, #0
/*
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
c64c: e5947000 ldr r7, [r4]
for ( i=0 ; i<entries ; i++ ) {
c650: da00000c ble c688 <memfile_free_blocks_in_table+0x50>
c654: e3a05000 mov r5, #0
c658: e1a06005 mov r6, r5
if ( b[i] ) {
memfile_free_block( b[i] );
b[i] = 0;
c65c: e1a0a005 mov sl, r5
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
if ( b[i] ) {
c660: e7970005 ldr r0, [r7, r5]
c664: e3500000 cmp r0, #0
c668: 0a000001 beq c674 <memfile_free_blocks_in_table+0x3c>
memfile_free_block( b[i] );
c66c: ebffff50 bl c3b4 <memfile_free_block>
b[i] = 0;
c670: e787a005 str sl, [r7, r5]
* Now go through all the slots in the table and free the memory.
*/
b = *block_table;
for ( i=0 ; i<entries ; i++ ) {
c674: e2866001 add r6, r6, #1
c678: e1580006 cmp r8, r6
c67c: e2855004 add r5, r5, #4
c680: cafffff6 bgt c660 <memfile_free_blocks_in_table+0x28>
c684: e5947000 ldr r7, [r4]
/*
* Now that all the blocks in the block table are free, we can
* free the block table itself.
*/
memfile_free_block( *block_table );
c688: e1a00007 mov r0, r7
c68c: ebffff48 bl c3b4 <memfile_free_block>
*block_table = 0;
c690: e3a03000 mov r3, #0
c694: e5843000 str r3, [r4]
}
c698: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
/*
* Perform internal consistency checks
*/
assert( block_table );
c69c: e3a01e1b mov r1, #432 ; 0x1b0 <== NOT EXECUTED
c6a0: e2811003 add r1, r1, #3 <== NOT EXECUTED
c6a4: e59f0008 ldr r0, [pc, #8] ; c6b4 <memfile_free_blocks_in_table+0x7c><== NOT EXECUTED
c6a8: e59f2008 ldr r2, [pc, #8] ; c6b8 <memfile_free_blocks_in_table+0x80><== NOT EXECUTED
c6ac: e59f3008 ldr r3, [pc, #8] ; c6bc <memfile_free_blocks_in_table+0x84><== NOT EXECUTED
c6b0: ebfff927 bl ab54 <__assert_func> <== NOT EXECUTED
0000cb90 <memfile_ftruncate>:
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
cb90: e92d4010 push {r4, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
cb94: e5904038 ldr r4, [r0, #56] ; 0x38
* POSIX 1003.1b does not specify what happens if you truncate a file
* and the new length is greater than the current size. We treat this
* as an extend operation.
*/
if ( length > the_jnode->info.file.size )
cb98: e5943054 ldr r3, [r4, #84] ; 0x54
cb9c: e1530002 cmp r3, r2
int memfile_ftruncate(
rtems_libio_t *iop,
rtems_off64_t length
)
{
cba0: e24dd008 sub sp, sp, #8
* POSIX 1003.1b does not specify what happens if you truncate a file
* and the new length is greater than the current size. We treat this
* as an extend operation.
*/
if ( length > the_jnode->info.file.size )
cba4: ba00000e blt cbe4 <memfile_ftruncate+0x54>
cba8: 0a00000a beq cbd8 <memfile_ftruncate+0x48>
* The in-memory files do not currently reclaim memory until the file is
* deleted. So we leave the previously allocated blocks in place for
* future use and just set the length.
*/
the_jnode->info.file.size = length;
cbac: e5841050 str r1, [r4, #80] ; 0x50
cbb0: e5842054 str r2, [r4, #84] ; 0x54
iop->size = the_jnode->info.file.size;
cbb4: e9800006 stmib r0, {r1, r2}
IMFS_update_atime( the_jnode );
cbb8: e3a01000 mov r1, #0
cbbc: e1a0000d mov r0, sp
cbc0: ebffd561 bl 214c <gettimeofday>
cbc4: e59d3000 ldr r3, [sp]
cbc8: e5843040 str r3, [r4, #64] ; 0x40
cbcc: e3a00000 mov r0, #0
return 0;
}
cbd0: e28dd008 add sp, sp, #8
cbd4: e8bd8010 pop {r4, pc}
* POSIX 1003.1b does not specify what happens if you truncate a file
* and the new length is greater than the current size. We treat this
* as an extend operation.
*/
if ( length > the_jnode->info.file.size )
cbd8: e5943050 ldr r3, [r4, #80] ; 0x50
cbdc: e1530001 cmp r3, r1
cbe0: 2afffff1 bcs cbac <memfile_ftruncate+0x1c>
return IMFS_memfile_extend( the_jnode, length );
cbe4: e1a00004 mov r0, r4 <== NOT EXECUTED
cbe8: ebffff87 bl ca0c <IMFS_memfile_extend> <== NOT EXECUTED
cbec: eafffff7 b cbd0 <memfile_ftruncate+0x40> <== NOT EXECUTED
0000cbf0 <memfile_lseek>:
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
cbf0: e92d4030 push {r4, r5, lr}
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
cbf4: e5905038 ldr r5, [r0, #56] ; 0x38
if (the_jnode->type == IMFS_LINEAR_FILE) {
cbf8: e595304c ldr r3, [r5, #76] ; 0x4c
cbfc: e3530006 cmp r3, #6
rtems_off64_t memfile_lseek(
rtems_libio_t *iop,
rtems_off64_t offset,
int whence
)
{
cc00: e1a04000 mov r4, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
if (the_jnode->type == IMFS_LINEAR_FILE) {
cc04: 0a00000d beq cc40 <memfile_lseek+0x50>
if (iop->offset > the_jnode->info.linearfile.size)
iop->offset = the_jnode->info.linearfile.size;
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
cc08: e1a00005 mov r0, r5
cc0c: e284200c add r2, r4, #12
cc10: e8920006 ldm r2, {r1, r2}
cc14: ebffff7c bl ca0c <IMFS_memfile_extend>
cc18: e3500000 cmp r0, #0
cc1c: 1a00001a bne cc8c <memfile_lseek+0x9c>
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
cc20: e2853050 add r3, r5, #80 ; 0x50
cc24: e893000c ldm r3, {r2, r3}
cc28: e984000c stmib r4, {r2, r3}
cc2c: e284300c add r3, r4, #12
cc30: e893000c ldm r3, {r2, r3}
} return iop->offset; }
cc34: e1a01003 mov r1, r3
cc38: e1a00002 mov r0, r2
cc3c: e8bd8030 pop {r4, r5, pc}
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
if (the_jnode->type == IMFS_LINEAR_FILE) {
if (iop->offset > the_jnode->info.linearfile.size)
cc40: e5901010 ldr r1, [r0, #16] <== NOT EXECUTED
cc44: e2853050 add r3, r5, #80 ; 0x50 <== NOT EXECUTED
cc48: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
cc4c: e1510003 cmp r1, r3 <== NOT EXECUTED
cc50: e590000c ldr r0, [r0, #12] <== NOT EXECUTED
cc54: ca000007 bgt cc78 <memfile_lseek+0x88> <== NOT EXECUTED
cc58: 0a000004 beq cc70 <memfile_lseek+0x80> <== NOT EXECUTED
cc5c: e1a02000 mov r2, r0 <== NOT EXECUTED
cc60: e1a03001 mov r3, r1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
}
return iop->offset;
}
cc64: e1a01003 mov r1, r3 <== NOT EXECUTED
cc68: e1a00002 mov r0, r2 <== NOT EXECUTED
cc6c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
if (the_jnode->type == IMFS_LINEAR_FILE) {
if (iop->offset > the_jnode->info.linearfile.size)
cc70: e1500002 cmp r0, r2 <== NOT EXECUTED
cc74: 9afffff8 bls cc5c <memfile_lseek+0x6c> <== NOT EXECUTED
iop->offset = the_jnode->info.linearfile.size;
cc78: e584200c str r2, [r4, #12] <== NOT EXECUTED
cc7c: e5843010 str r3, [r4, #16] <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOSPC );
iop->size = the_jnode->info.file.size;
}
return iop->offset;
}
cc80: e1a01003 mov r1, r3 <== NOT EXECUTED
cc84: e1a00002 mov r0, r2 <== NOT EXECUTED
cc88: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if (iop->offset > the_jnode->info.linearfile.size)
iop->offset = the_jnode->info.linearfile.size;
}
else { /* Must be a block file (IMFS_MEMORY_FILE). */
if (IMFS_memfile_extend( the_jnode, iop->offset ))
rtems_set_errno_and_return_minus_one( ENOSPC );
cc8c: eb00058b bl e2c0 <__errno> <== NOT EXECUTED
cc90: e3a0301c mov r3, #28 <== NOT EXECUTED
cc94: e5803000 str r3, [r0] <== NOT EXECUTED
cc98: e3e02000 mvn r2, #0 <== NOT EXECUTED
cc9c: e3e03000 mvn r3, #0 <== NOT EXECUTED
cca0: eaffffe3 b cc34 <memfile_lseek+0x44> <== NOT EXECUTED
0000cf68 <memfile_open>:
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
cf68: e92d4830 push {r4, r5, fp, lr}
the_jnode = iop->file_info;
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
cf6c: e5903014 ldr r3, [r0, #20]
cf70: e3130f81 tst r3, #516 ; 0x204
rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode
)
{
cf74: e24dd004 sub sp, sp, #4
cf78: e1a04000 mov r4, r0
IMFS_jnode_t *the_jnode;
the_jnode = iop->file_info;
cf7c: e5905038 ldr r5, [r0, #56] ; 0x38
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
cf80: 0a000002 beq cf90 <memfile_open+0x28>
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
cf84: e595204c ldr r2, [r5, #76] ; 0x4c
cf88: e3520006 cmp r2, #6
cf8c: 0a00000b beq cfc0 <memfile_open+0x58>
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
cf90: e5952050 ldr r2, [r5, #80] ; 0x50
cf94: e5951054 ldr r1, [r5, #84] ; 0x54
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
return -1;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
cf98: e3130c02 tst r3, #512 ; 0x200
iop->offset = the_jnode->info.file.size;
cf9c: 1584200c strne r2, [r4, #12]
cfa0: 15841010 strne r1, [r4, #16]
cfa4: 15951054 ldrne r1, [r5, #84] ; 0x54
cfa8: 15952050 ldrne r2, [r5, #80] ; 0x50
iop->size = the_jnode->info.file.size;
cfac: e5841008 str r1, [r4, #8]
cfb0: e5842004 str r2, [r4, #4]
cfb4: e3a00000 mov r0, #0
return 0; }
cfb8: e28dd004 add sp, sp, #4
cfbc: e8bd8830 pop {r4, r5, fp, pc}
/*
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
cfc0: e595c050 ldr ip, [r5, #80] ; 0x50 <== NOT EXECUTED
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
cfc4: e3a00000 mov r0, #0 <== NOT EXECUTED
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
cfc8: e3a03005 mov r3, #5 <== NOT EXECUTED
the_jnode->info.file.size = 0;
cfcc: e3a01000 mov r1, #0 <== NOT EXECUTED
cfd0: e3a02000 mov r2, #0 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
cfd4: e35c0000 cmp ip, #0 <== NOT EXECUTED
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
cfd8: e585304c str r3, [r5, #76] ; 0x4c <== NOT EXECUTED
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
cfdc: e5850060 str r0, [r5, #96] ; 0x60 <== NOT EXECUTED
* Perform 'copy on write' for linear files
*/
if ((iop->flags & (LIBIO_FLAGS_WRITE | LIBIO_FLAGS_APPEND))
&& (the_jnode->type == IMFS_LINEAR_FILE)) {
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
cfe0: e5953058 ldr r3, [r5, #88] ; 0x58 <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
cfe4: e5851050 str r1, [r5, #80] ; 0x50 <== NOT EXECUTED
cfe8: e5852054 str r2, [r5, #84] ; 0x54 <== NOT EXECUTED
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
cfec: e585005c str r0, [r5, #92] ; 0x5c <== NOT EXECUTED
uint32_t count = the_jnode->info.linearfile.size;
const unsigned char *buffer = the_jnode->info.linearfile.direct;
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
cff0: e5850058 str r0, [r5, #88] ; 0x58 <== NOT EXECUTED
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
cff4: 1a000004 bne d00c <memfile_open+0xa4> <== NOT EXECUTED
cff8: e1a0b001 mov fp, r1 <== NOT EXECUTED
cffc: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
d000: e1a01002 mov r1, r2 <== NOT EXECUTED
d004: e1a0200b mov r2, fp <== NOT EXECUTED
d008: eaffffe2 b cf98 <memfile_open+0x30> <== NOT EXECUTED
&& (IMFS_memfile_write(the_jnode, 0, buffer, count) == -1))
d00c: e1a00005 mov r0, r5 <== NOT EXECUTED
d010: e58dc000 str ip, [sp] <== NOT EXECUTED
d014: ebffff22 bl cca4 <IMFS_memfile_write> <== NOT EXECUTED
the_jnode->type = IMFS_MEMORY_FILE;
the_jnode->info.file.size = 0;
the_jnode->info.file.indirect = 0;
the_jnode->info.file.doubly_indirect = 0;
the_jnode->info.file.triply_indirect = 0;
if ((count != 0)
d018: e3700001 cmn r0, #1 <== NOT EXECUTED
d01c: 0affffe5 beq cfb8 <memfile_open+0x50> <== NOT EXECUTED
d020: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
d024: eaffffd9 b cf90 <memfile_open+0x28> <== NOT EXECUTED
00002518 <mknod>:
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
2518: e92d41f0 push {r4, r5, r6, r7, r8, lr}
251c: e1a06001 mov r6, r1
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
2520: e2011a0f and r1, r1, #61440 ; 0xf000
2524: e3510901 cmp r1, #16384 ; 0x4000
int mknod(
const char *pathname,
mode_t mode,
dev_t dev
)
{
2528: e24dd020 sub sp, sp, #32
252c: e1a05000 mov r5, r0
2530: e1a07002 mov r7, r2
2534: e1a08003 mov r8, r3
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
2538: 0a00000d beq 2574 <mknod+0x5c>
253c: 9a000008 bls 2564 <mknod+0x4c>
2540: e3510a06 cmp r1, #24576 ; 0x6000
2544: 0a00000a beq 2574 <mknod+0x5c>
2548: e3510902 cmp r1, #32768 ; 0x8000
254c: 0a000008 beq 2574 <mknod+0x5c>
case S_IFBLK:
case S_IFREG:
case S_IFIFO:
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
2550: eb002f5a bl e2c0 <__errno> <== NOT EXECUTED
2554: e3a03016 mov r3, #22 <== NOT EXECUTED
2558: e5803000 str r3, [r0] <== NOT EXECUTED
255c: e3e05000 mvn r5, #0 <== NOT EXECUTED
2560: ea000028 b 2608 <mknod+0xf0> <== NOT EXECUTED
int result;
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & S_IFMT)
2564: e3510a01 cmp r1, #4096 ; 0x1000
2568: 0a000001 beq 2574 <mknod+0x5c>
256c: e3510a02 cmp r1, #8192 ; 0x2000
2570: 1afffff6 bne 2550 <mknod+0x38>
break;
default:
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_filesystem_get_start_loc( pathname, &i, &temp_loc );
2574: e28d4004 add r4, sp, #4
2578: e1a00005 mov r0, r5
257c: e28d101c add r1, sp, #28
2580: e1a02004 mov r2, r4
2584: eb000289 bl 2fb0 <rtems_filesystem_get_start_loc>
if ( !temp_loc.ops->evalformake_h ) {
2588: e59d3010 ldr r3, [sp, #16]
258c: e5933004 ldr r3, [r3, #4]
2590: e3530000 cmp r3, #0
2594: 0a000023 beq 2628 <mknod+0x110>
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->evalformake_h)(
2598: e59d001c ldr r0, [sp, #28]
259c: e1a01004 mov r1, r4
25a0: e0850000 add r0, r5, r0
25a4: e28d2018 add r2, sp, #24
25a8: e1a0e00f mov lr, pc
25ac: e12fff13 bx r3
&pathname[i],
&temp_loc,
&name_start
);
if ( result != 0 )
25b0: e3500000 cmp r0, #0
25b4: 1a00001e bne 2634 <mknod+0x11c>
return -1;
if ( !temp_loc.ops->mknod_h ) {
25b8: e59d3010 ldr r3, [sp, #16]
25bc: e593c014 ldr ip, [r3, #20]
25c0: e35c0000 cmp ip, #0
25c4: 0a000012 beq 2614 <mknod+0xfc>
rtems_filesystem_freenode( &temp_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
25c8: e1a03008 mov r3, r8
25cc: e58d4000 str r4, [sp]
25d0: e59d0018 ldr r0, [sp, #24]
25d4: e1a01006 mov r1, r6
25d8: e1a02007 mov r2, r7
25dc: e1a0e00f mov lr, pc
25e0: e12fff1c bx ip
rtems_filesystem_freenode( &temp_loc );
25e4: e59d3010 ldr r3, [sp, #16]
25e8: e3530000 cmp r3, #0
if ( !temp_loc.ops->mknod_h ) {
rtems_filesystem_freenode( &temp_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->mknod_h)( name_start, mode, dev, &temp_loc );
25ec: e1a05000 mov r5, r0
rtems_filesystem_freenode( &temp_loc );
25f0: 0a000004 beq 2608 <mknod+0xf0>
25f4: e593301c ldr r3, [r3, #28]
25f8: e3530000 cmp r3, #0
25fc: 11a00004 movne r0, r4
2600: 11a0e00f movne lr, pc
2604: 112fff13 bxne r3
return result;
}
2608: e1a00005 mov r0, r5
260c: e28dd020 add sp, sp, #32
2610: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
);
if ( result != 0 )
return -1;
if ( !temp_loc.ops->mknod_h ) {
rtems_filesystem_freenode( &temp_loc );
2614: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
2618: e3530000 cmp r3, #0 <== NOT EXECUTED
261c: 11a00004 movne r0, r4 <== NOT EXECUTED
2620: 11a0e00f movne lr, pc <== NOT EXECUTED
2624: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
2628: eb002f24 bl e2c0 <__errno> <== NOT EXECUTED
262c: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
2630: e5803000 str r3, [r0] <== NOT EXECUTED
2634: e3e05000 mvn r5, #0
2638: eafffff2 b 2608 <mknod+0xf0>
000026c8 <mount>:
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
26c8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
26cc: e3530001 cmp r3, #1
const char *target,
const char *filesystemtype,
rtems_filesystem_options_t options,
const void *data
)
{
26d0: e24dd028 sub sp, sp, #40 ; 0x28
26d4: e58d3004 str r3, [sp, #4]
26d8: e1a08000 mov r8, r0
26dc: e1a07001 mov r7, r1
26e0: e1a0a002 mov sl, r2
/*
* Are the file system options valid?
*/
if ( options != RTEMS_FILESYSTEM_READ_ONLY &&
26e4: 8a00009e bhi 2964 <mount+0x29c>
rtems_set_errno_and_return_minus_one( EINVAL );
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
26e8: e1a00002 mov r0, r2
26ec: eb0022ad bl b1a8 <rtems_filesystem_get_mount_handler>
if ( !mount_h )
26f0: e3500000 cmp r0, #0
26f4: e58d000c str r0, [sp, #12]
26f8: 0a000099 beq 2964 <mount+0x29c>
{
rtems_filesystem_fsmount_me_t mount_h = NULL;
rtems_filesystem_location_info_t loc;
rtems_filesystem_mount_table_entry_t *mt_entry = NULL;
rtems_filesystem_location_info_t *loc_to_free = NULL;
bool has_target = target != NULL;
26fc: e2575000 subs r5, r7, #0
2700: 13a05001 movne r5, #1
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
2704: e3550000 cmp r5, #0
2708: 0a000090 beq 2950 <mount+0x288>
* 4) The mount point exists with the proper permissions to allow mounting
* 5) The selected mount point already has a file system mounted to it
*
*/
int mount(
270c: e1a00007 mov r0, r7
2710: e58d7010 str r7, [sp, #16]
2714: eb0032ee bl f2d4 <strlen>
2718: e58d0008 str r0, [sp, #8]
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
271c: e1a0000a mov r0, sl
2720: eb0032eb bl f2d4 <strlen>
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
2724: e3580000 cmp r8, #0
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
size_t filesystemtype_size = strlen( filesystemtype ) + 1;
2728: e2806001 add r6, r0, #1
size_t source_size = source_or_null != NULL ?
strlen( source_or_null ) + 1 : 0;
272c: 01a0b008 moveq fp, r8
2730: 0a000002 beq 2740 <mount+0x78>
2734: e1a00008 mov r0, r8
2738: eb0032e5 bl f2d4 <strlen>
273c: e280b001 add fp, r0, #1
size_t target_length = strlen( target );
size_t size = sizeof( rtems_filesystem_mount_table_entry_t )
+ filesystemtype_size + source_size + target_length + 1;
rtems_filesystem_mount_table_entry_t *mt_entry = calloc( 1, size );
2740: e59d3008 ldr r3, [sp, #8]
2744: e2831075 add r1, r3, #117 ; 0x75
2748: e0811006 add r1, r1, r6
274c: e081100b add r1, r1, fp
2750: e3a00001 mov r0, #1
2754: ebfffdbd bl 1e50 <calloc>
if ( mt_entry != NULL ) {
2758: e2504000 subs r4, r0, #0
275c: 0a000076 beq 293c <mount+0x274>
char *str = (char *) mt_entry + sizeof( *mt_entry );
2760: e2849074 add r9, r4, #116 ; 0x74
strcpy( str, filesystemtype );
2764: e1a0100a mov r1, sl
2768: e1a00009 mov r0, r9
276c: eb003288 bl f194 <strcpy>
mt_entry->type = str;
str += filesystemtype_size;
if ( source_or_null != NULL ) {
2770: e3580000 cmp r8, #0
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
strcpy( str, filesystemtype );
mt_entry->type = str;
str += filesystemtype_size;
2774: e0896006 add r6, r9, r6
if ( mt_entry != NULL ) {
char *str = (char *) mt_entry + sizeof( *mt_entry );
strcpy( str, filesystemtype );
mt_entry->type = str;
2778: e584906c str r9, [r4, #108] ; 0x6c
str += filesystemtype_size;
if ( source_or_null != NULL ) {
277c: 0a000004 beq 2794 <mount+0xcc>
strcpy( str, source_or_null );
2780: e1a00006 mov r0, r6
2784: e1a01008 mov r1, r8
2788: eb003281 bl f194 <strcpy>
mt_entry->dev = str;
278c: e5846070 str r6, [r4, #112] ; 0x70
str += source_size;
2790: e086600b add r6, r6, fp
}
strcpy( str, target );
2794: e59d1010 ldr r1, [sp, #16]
2798: e1a00006 mov r0, r6
279c: eb00327c bl f194 <strcpy>
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
mt_entry->options = options;
mt_entry->pathconf_limits_and_options = rtems_filesystem_default_pathconf;
27a0: e59fe24c ldr lr, [pc, #588] ; 29f4 <mount+0x32c>
27a4: e8be000f ldm lr!, {r0, r1, r2, r3}
27a8: e284c038 add ip, r4, #56 ; 0x38
27ac: e8ac000f stmia ip!, {r0, r1, r2, r3}
27b0: e8be000f ldm lr!, {r0, r1, r2, r3}
27b4: e8ac000f stmia ip!, {r0, r1, r2, r3}
27b8: e89e000f ldm lr, {r0, r1, r2, r3}
27bc: e88c000f stm ip, {r0, r1, r2, r3}
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
mt_entry->options = options;
27c0: e59d3004 ldr r3, [sp, #4]
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
27c4: e3550000 cmp r5, #0
mt_entry->dev = str;
str += source_size;
}
strcpy( str, target );
mt_entry->target = str;
27c8: e5846068 str r6, [r4, #104] ; 0x68
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
mt_entry->options = options;
27cc: e5843030 str r3, [r4, #48] ; 0x30
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
mt_entry->mt_fs_root.mt_entry = mt_entry;
27d0: e584402c str r4, [r4, #44] ; 0x2c
/*
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
27d4: 1a000023 bne 2868 <mount+0x1a0>
}
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
27d8: e59f3218 ldr r3, [pc, #536] ; 29f8 <mount+0x330>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
27dc: e5932000 ldr r2, [r3]
27e0: e2833004 add r3, r3, #4
27e4: e1520003 cmp r2, r3
27e8: 01a06005 moveq r6, r5
27ec: 1a00006d bne 29a8 <mount+0x2e0>
* mt_point_node.node_access will be left to null to indicate that this
* is the root of the entire file system.
*/
}
if ( (*mount_h)( mt_entry, data ) ) {
27f0: e59d104c ldr r1, [sp, #76] ; 0x4c
27f4: e1a00004 mov r0, r4
27f8: e59d300c ldr r3, [sp, #12]
27fc: e1a0e00f mov lr, pc
2800: e12fff13 bx r3
2804: e2507000 subs r7, r0, #0
2808: 1a00005a bne 2978 <mount+0x2b0>
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
280c: e59f61e8 ldr r6, [pc, #488] ; 29fc <mount+0x334>
2810: e1a02007 mov r2, r7
2814: e1a01007 mov r1, r7
2818: e5960000 ldr r0, [r6]
281c: eb000be2 bl 57ac <rtems_semaphore_obtain>
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
2820: e1a01004 mov r1, r4
2824: e59f01cc ldr r0, [pc, #460] ; 29f8 <mount+0x330>
2828: eb000e23 bl 60bc <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
282c: e5960000 ldr r0, [r6]
2830: eb000c25 bl 58cc <rtems_semaphore_release>
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
2834: e3550000 cmp r5, #0
rtems_filesystem_root = mt_entry->mt_fs_root;
2838: 059f31c0 ldreq r3, [pc, #448] ; 2a00 <mount+0x338>
283c: 0284401c addeq r4, r4, #28
2840: 0593c000 ldreq ip, [r3]
2844: 08b4000f ldmeq r4!, {r0, r1, r2, r3}
2848: 028cc018 addeq ip, ip, #24
284c: 08ac000f stmiaeq ip!, {r0, r1, r2, r3}
2850: 05943000 ldreq r3, [r4]
2854: 058c3000 streq r3, [ip]
*/
rtems_libio_lock();
rtems_chain_append( &mount_chain, &mt_entry->Node );
rtems_libio_unlock();
if ( !has_target )
2858: 11a00007 movne r0, r7
rtems_filesystem_root = mt_entry->mt_fs_root;
285c: 01a00005 moveq r0, r5
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
return -1;
}
2860: e28dd028 add sp, sp, #40 ; 0x28
2864: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
* The mount_point should be a directory with read/write/execute
* permissions in the existing tree.
*/
if ( has_target ) {
if ( rtems_filesystem_evaluate_path(
2868: e28d6014 add r6, sp, #20
286c: e3a0c001 mov ip, #1
2870: e1a00007 mov r0, r7
2874: e59d1008 ldr r1, [sp, #8]
2878: e3a02007 mov r2, #7
287c: e1a03006 mov r3, r6
2880: e58dc000 str ip, [sp]
2884: ebfffde5 bl 2020 <rtems_filesystem_evaluate_path>
2888: e3700001 cmn r0, #1
288c: 0a000048 beq 29b4 <mount+0x2ec>
/*
* Test for node_type_h
*/
if (!loc.ops->node_type_h) {
2890: e59d3020 ldr r3, [sp, #32]
2894: e5933010 ldr r3, [r3, #16]
2898: e3530000 cmp r3, #0
289c: 0a000050 beq 29e4 <mount+0x31c>
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
28a0: e1a00006 mov r0, r6
28a4: e1a0e00f mov lr, pc
28a8: e12fff13 bx r3
28ac: e3500001 cmp r0, #1
28b0: 1a000043 bne 29c4 <mount+0x2fc>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
28b4: e59f0148 ldr r0, [pc, #328] ; 2a04 <mount+0x33c>
28b8: e59d1014 ldr r1, [sp, #20]
28bc: ebffff63 bl 2650 <rtems_filesystem_mount_iterate>
28c0: e3500000 cmp r0, #0
28c4: 1a000042 bne 29d4 <mount+0x30c>
* may have been allocated in loc should not be sent to freenode
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
28c8: e59d1014 ldr r1, [sp, #20]
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
28cc: e59d2020 ldr r2, [sp, #32]
* may have been allocated in loc should not be sent to freenode
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
28d0: e5841008 str r1, [r4, #8]
mt_entry->mt_point_node.handlers = loc.handlers;
28d4: e59d101c ldr r1, [sp, #28]
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( !loc.ops->mount_h ){
28d8: e5923020 ldr r3, [r2, #32]
* until the system is unmounted. It may be needed to correctly
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
28dc: e5841010 str r1, [r4, #16]
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
28e0: e59d1024 ldr r1, [sp, #36] ; 0x24
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( !loc.ops->mount_h ){
28e4: e3530000 cmp r3, #0
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
mt_entry->mt_point_node.mt_entry = loc.mt_entry;
28e8: e5841018 str r1, [r4, #24]
* traverse the tree.
*/
mt_entry->mt_point_node.node_access = loc.node_access;
mt_entry->mt_point_node.handlers = loc.handlers;
mt_entry->mt_point_node.ops = loc.ops;
28ec: e5842014 str r2, [r4, #20]
/*
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( !loc.ops->mount_h ){
28f0: 0a00003b beq 29e4 <mount+0x31c>
errno = ENOTSUP;
goto cleanup_and_bail;
}
if ( loc.ops->mount_h( mt_entry ) ) {
28f4: e1a00004 mov r0, r4
28f8: e1a0e00f mov lr, pc
28fc: e12fff13 bx r3
2900: e3500000 cmp r0, #0
2904: 0affffb9 beq 27f0 <mount+0x128>
return 0;
cleanup_and_bail:
free( mt_entry );
2908: e1a00004 mov r0, r4
290c: ebfffde5 bl 20a8 <free>
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
2910: e596300c ldr r3, [r6, #12]
2914: e3530000 cmp r3, #0
2918: 0a000020 beq 29a0 <mount+0x2d8>
291c: e593301c ldr r3, [r3, #28]
2920: e3530000 cmp r3, #0
2924: 0a00001d beq 29a0 <mount+0x2d8>
2928: e1a00006 mov r0, r6
292c: e1a0e00f mov lr, pc
2930: e12fff13 bx r3
2934: e3e00000 mvn r0, #0
2938: eaffffc8 b 2860 <mount+0x198>
target,
filesystemtype,
&target_length
);
if ( !mt_entry )
rtems_set_errno_and_return_minus_one( ENOMEM );
293c: eb002e5f bl e2c0 <__errno> <== NOT EXECUTED
2940: e3a0300c mov r3, #12 <== NOT EXECUTED
2944: e5803000 str r3, [r0] <== NOT EXECUTED
2948: e3e00000 mvn r0, #0 <== NOT EXECUTED
294c: eaffffc3 b 2860 <mount+0x198> <== NOT EXECUTED
const char *target_or_null,
const char *filesystemtype,
size_t *target_length_ptr
)
{
const char *target = target_or_null != NULL ? target_or_null : "/";
2950: e3a03001 mov r3, #1
2954: e58d3008 str r3, [sp, #8]
2958: e59f30a8 ldr r3, [pc, #168] ; 2a08 <mount+0x340>
295c: e58d3010 str r3, [sp, #16]
2960: eaffff6d b 271c <mount+0x54>
/*
* Get mount handler
*/
mount_h = rtems_filesystem_get_mount_handler( filesystemtype );
if ( !mount_h )
rtems_set_errno_and_return_minus_one( EINVAL );
2964: eb002e55 bl e2c0 <__errno>
2968: e3a03016 mov r3, #22
296c: e5803000 str r3, [r0]
2970: e3e00000 mvn r0, #0
2974: eaffffb9 b 2860 <mount+0x198>
if ( (*mount_h)( mt_entry, data ) ) {
/*
* Try to undo the mount operation
*/
if ( loc.ops->unmount_h ) {
2978: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
297c: e5933028 ldr r3, [r3, #40] ; 0x28 <== NOT EXECUTED
2980: e3530000 cmp r3, #0 <== NOT EXECUTED
loc.ops->unmount_h( mt_entry );
2984: 11a00004 movne r0, r4 <== NOT EXECUTED
2988: 11a0e00f movne lr, pc <== NOT EXECUTED
298c: 112fff13 bxne r3 <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
2990: e1a00004 mov r0, r4 <== NOT EXECUTED
2994: ebfffdc3 bl 20a8 <free> <== NOT EXECUTED
if ( loc_to_free )
2998: e3560000 cmp r6, #0 <== NOT EXECUTED
299c: 1affffdb bne 2910 <mount+0x248> <== NOT EXECUTED
rtems_filesystem_freenode( loc_to_free );
29a0: e3e00000 mvn r0, #0 <== NOT EXECUTED
29a4: eaffffad b 2860 <mount+0x198> <== NOT EXECUTED
} else {
/*
* Do we already have a base file system ?
*/
if ( !rtems_chain_is_empty( &mount_chain ) ) {
errno = EINVAL;
29a8: eb002e44 bl e2c0 <__errno> <== NOT EXECUTED
29ac: e3a03016 mov r3, #22 <== NOT EXECUTED
29b0: e5803000 str r3, [r0] <== NOT EXECUTED
return 0;
cleanup_and_bail:
free( mt_entry );
29b4: e1a00004 mov r0, r4 <== NOT EXECUTED
29b8: ebfffdba bl 20a8 <free> <== NOT EXECUTED
29bc: e3e00000 mvn r0, #0 <== NOT EXECUTED
29c0: eaffffa6 b 2860 <mount+0x198> <== NOT EXECUTED
/*
* Test to see if it is a directory
*/
if ( loc.ops->node_type_h( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ) {
errno = ENOTDIR;
29c4: eb002e3d bl e2c0 <__errno>
29c8: e3a03014 mov r3, #20
29cc: e5803000 str r3, [r0]
goto cleanup_and_bail;
29d0: eaffffcc b 2908 <mount+0x240>
/*
* You can only mount one file system onto a single mount point.
*/
if ( rtems_filesystem_mount_iterate( is_node_fs_root, loc.node_access ) ) {
errno = EBUSY;
29d4: eb002e39 bl e2c0 <__errno>
29d8: e3a03010 mov r3, #16
29dc: e5803000 str r3, [r0]
goto cleanup_and_bail;
29e0: eaffffc8 b 2908 <mount+0x240>
* This link to the parent is only done when we are dealing with system
* below the base file system
*/
if ( !loc.ops->mount_h ){
errno = ENOTSUP;
29e4: eb002e35 bl e2c0 <__errno> <== NOT EXECUTED
29e8: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
29ec: e5803000 str r3, [r0] <== NOT EXECUTED
goto cleanup_and_bail;
29f0: eaffffc4 b 2908 <mount+0x240> <== NOT EXECUTED
00035ecc <msdos_creat_node>:
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
35ecc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
35ed0: e24dd0ac sub sp, sp, #172 ; 0xac <== NOT EXECUTED
35ed4: e1a06000 mov r6, r0 <== NOT EXECUTED
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
35ed8: e28d5074 add r5, sp, #116 ; 0x74 <== NOT EXECUTED
mode_t mode,
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
35edc: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
fat_file_fd_t *fat_fd = NULL;
35ee0: e3a04000 mov r4, #0 <== NOT EXECUTED
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
35ee4: e285c008 add ip, r5, #8 <== NOT EXECUTED
mode_t mode,
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
35ee8: e5900034 ldr r0, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t sec = 0;
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
35eec: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 35ef0: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 35ef4: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 35ef8: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 35efc: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 35f00: e58d4074 str r4, [sp, #116] ; 0x74 <== NOT EXECUTED 35f04: e58c4000 str r4, [ip] <== NOT EXECUTED 35f08: e58d4078 str r4, [sp, #120] ; 0x78 <== NOT EXECUTED
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
35f0c: e1a08003 mov r8, r3 <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
35f10: e3e03000 mvn r3, #0 <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
35f14: e58d30a0 str r3, [sp, #160] ; 0xa0 <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
35f18: e58d309c str r3, [sp, #156] ; 0x9c <== NOT EXECUTED
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
35f1c: e28d9014 add r9, sp, #20 <== NOT EXECUTED
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
35f20: e5963000 ldr r3, [r6] <== NOT EXECUTED
mode_t mode,
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
35f24: e58d0010 str r0, [sp, #16] <== NOT EXECUTED
msdos_node_type_t type,
const char *name,
int name_len,
mode_t mode,
const fat_file_fd_t *link_fd)
{
35f28: e1a07002 mov r7, r2 <== NOT EXECUTED 35f2c: e1a0a001 mov sl, r1 <== NOT EXECUTED
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
35f30: e3a02040 mov r2, #64 ; 0x40 <== NOT EXECUTED 35f34: e1a01004 mov r1, r4 <== NOT EXECUTED 35f38: e1a00009 mov r0, r9 <== NOT EXECUTED
const fat_file_fd_t *link_fd)
{
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *parent_fat_fd = parent_loc->node_access;
35f3c: e58d300c str r3, [sp, #12] <== NOT EXECUTED
fat_file_fd_t *fat_fd = NULL;
35f40: e58d40a4 str r4, [sp, #164] ; 0xa4 <== NOT EXECUTED
time_t time_ret = 0;
uint16_t time_val = 0;
35f44: e1cd4aba strh r4, [sp, #170] ; 0xaa <== NOT EXECUTED
uint16_t date = 0;
35f48: e1cd4ab8 strh r4, [sp, #168] ; 0xa8 <== NOT EXECUTED
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
35f4c: e58d4094 str r4, [sp, #148] ; 0x94 <== NOT EXECUTED
dir_pos->sname.ofs = 0;
35f50: e58d4098 str r4, [sp, #152] ; 0x98 <== NOT EXECUTED
uint32_t byte = 0;
fat_dir_pos_init(&dir_pos);
memset(short_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memset(dot_dotdot, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2);
35f54: eb00415c bl 464cc <memset> <== NOT EXECUTED
name_type = msdos_long_to_short (name, name_len,
35f58: e1a01008 mov r1, r8 <== NOT EXECUTED 35f5c: e1a02005 mov r2, r5 <== NOT EXECUTED 35f60: e3a0300b mov r3, #11 <== NOT EXECUTED 35f64: e1a00007 mov r0, r7 <== NOT EXECUTED 35f68: eb000811 bl 37fb4 <msdos_long_to_short> <== NOT EXECUTED 35f6c: e1a0b000 mov fp, r0 <== NOT EXECUTED
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
/* set up last write date and time */
time_ret = time(NULL);
35f70: e1a00004 mov r0, r4 <== NOT EXECUTED
name_type = msdos_long_to_short (name, name_len,
MSDOS_DIR_NAME(short_node),
MSDOS_NAME_MAX);
/* fill reserved field */
*MSDOS_DIR_NT_RES(short_node) = MSDOS_RES_NT_VALUE;
35f74: e5cd4080 strb r4, [sp, #128] ; 0x80 <== NOT EXECUTED
/* set up last write date and time */
time_ret = time(NULL);
35f78: eb00638e bl 4edb8 <time> <== NOT EXECUTED
if ( time_ret == -1 )
35f7c: e3700001 cmn r0, #1 <== NOT EXECUTED 35f80: 0a00001d beq 35ffc <msdos_creat_node+0x130> <== NOT EXECUTED
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
35f84: e28d10a8 add r1, sp, #168 ; 0xa8 <== NOT EXECUTED 35f88: e28d20aa add r2, sp, #170 ; 0xaa <== NOT EXECUTED 35f8c: eb002d3c bl 41484 <msdos_date_unix2dos> <== NOT EXECUTED
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
35f90: e1ddeaba ldrh lr, [sp, #170] ; 0xaa <== NOT EXECUTED
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
35f94: e1dd1ab8 ldrh r1, [sp, #168] ; 0xa8 <== NOT EXECUTED
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
35f98: e35a0001 cmp sl, #1 <== NOT EXECUTED
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
35f9c: e58d4090 str r4, [sp, #144] ; 0x90 <== NOT EXECUTED
time_ret = time(NULL);
if ( time_ret == -1 )
return -1;
msdos_date_unix2dos(time_ret, &date, &time_val);
*MSDOS_DIR_WRITE_TIME(short_node) = CT_LE_W(time_val);
35fa0: e1cde8ba strh lr, [sp, #138] ; 0x8a <== NOT EXECUTED
*MSDOS_DIR_WRITE_DATE(short_node) = CT_LE_W(date);
35fa4: e1cd18bc strh r1, [sp, #140] ; 0x8c <== NOT EXECUTED
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
35fa8: 0a000015 beq 36004 <msdos_creat_node+0x138> <== NOT EXECUTED
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
}
else if (type == MSDOS_HARD_LINK) {
35fac: e35a0003 cmp sl, #3 <== NOT EXECUTED 35fb0: 0a000073 beq 36184 <msdos_creat_node+0x2b8> <== NOT EXECUTED
* set "last access" date to today
*/
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
}
else { /* regular file... */
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
35fb4: e5dd307f ldrb r3, [sp, #127] ; 0x7f <== NOT EXECUTED 35fb8: e3833020 orr r3, r3, #32 <== NOT EXECUTED 35fbc: e5cd307f strb r3, [sp, #127] ; 0x7f <== NOT EXECUTED
/*
* find free space in the parent directory and write new initialized
* FAT 32 Bytes Directory Entry Structure to the disk
*/
rc = msdos_get_name_node(parent_loc, true, name, name_len,
35fc0: e1a02007 mov r2, r7 <== NOT EXECUTED
35fc4: e1a03008 mov r3, r8 <== NOT EXECUTED
35fc8: e28d4094 add r4, sp, #148 ; 0x94 <== NOT EXECUTED
35fcc: e1a00006 mov r0, r6 <== NOT EXECUTED
35fd0: e3a01001 mov r1, #1 <== NOT EXECUTED
35fd4: e58db000 str fp, [sp] <== NOT EXECUTED
35fd8: e98d0030 stmib sp, {r4, r5} <== NOT EXECUTED
35fdc: eb0008fd bl 383d8 <msdos_get_name_node> <== NOT EXECUTED
name_type, &dir_pos, short_node);
if ( rc != RC_OK )
35fe0: e2507000 subs r7, r0, #0 <== NOT EXECUTED 35fe4: 1a000001 bne 35ff0 <msdos_creat_node+0x124> <== NOT EXECUTED
/*
* if we create a new file we are done, if directory there are more steps
* to do
*/
if (type == MSDOS_DIRECTORY)
35fe8: e35a0001 cmp sl, #1 <== NOT EXECUTED 35fec: 0a000008 beq 36014 <msdos_creat_node+0x148> <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
}
35ff0: e1a00007 mov r0, r7 <== NOT EXECUTED
35ff4: e28dd0ac add sp, sp, #172 ; 0xac <== NOT EXECUTED
35ff8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
fat_file_close(parent_loc->mt_entry, fat_fd);
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
return rc;
35ffc: e3e07000 mvn r7, #0 <== NOT EXECUTED 36000: eafffffa b 35ff0 <msdos_creat_node+0x124> <== NOT EXECUTED
/* initialize directory/file size */
*MSDOS_DIR_FILE_SIZE(short_node) = MSDOS_INIT_DIR_SIZE;
if (type == MSDOS_DIRECTORY) {
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_DIRECTORY;
36004: e5dd307f ldrb r3, [sp, #127] ; 0x7f <== NOT EXECUTED 36008: e3833010 orr r3, r3, #16 <== NOT EXECUTED 3600c: e5cd307f strb r3, [sp, #127] ; 0x7f <== NOT EXECUTED 36010: eaffffea b 35fc0 <msdos_creat_node+0xf4> <== NOT EXECUTED
* to do
*/
if (type == MSDOS_DIRECTORY)
{
/* open new directory as fat-file */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
36014: e5960010 ldr r0, [r6, #16] <== NOT EXECUTED 36018: e1a01004 mov r1, r4 <== NOT EXECUTED 3601c: e28d20a4 add r2, sp, #164 ; 0xa4 <== NOT EXECUTED 36020: ebffbef6 bl 25c00 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
36024: e2507000 subs r7, r0, #0 <== NOT EXECUTED 36028: 1a000044 bne 36140 <msdos_creat_node+0x274> <== NOT EXECUTED
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
3602c: e59d30a4 ldr r3, [sp, #164] ; 0xa4 <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
36030: e3a02602 mov r2, #2097152 ; 0x200000 <== NOT EXECUTED 36034: e5832014 str r2, [r3, #20] <== NOT EXECUTED
/*
* we opened fat-file for node we just created, so initialize fat-file
* descritor
*/
fat_fd->fat_file_size = 0;
36038: e5837018 str r7, [r3, #24] <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
3603c: e583a010 str sl, [r3, #16] <== NOT EXECUTED
/*
* dot and dotdot entries are identical to new node except the
* names
*/
memcpy(DOT_NODE_P(dot_dotdot), short_node,
36040: e1a0e005 mov lr, r5 <== NOT EXECUTED
36044: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
36048: e1a0c009 mov ip, r9 <== NOT EXECUTED
3604c: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
36050: e89e000f ldm lr, {r0, r1, r2, r3} <== NOT EXECUTED
36054: e88c000f stm ip, {r0, r1, r2, r3} <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(DOTDOT_NODE_P(dot_dotdot), short_node,
36058: e8b5000f ldm r5!, {r0, r1, r2, r3} <== NOT EXECUTED
3605c: e2895020 add r5, r9, #32 <== NOT EXECUTED
36060: e1a0c005 mov ip, r5 <== NOT EXECUTED
36064: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
36068: e89e000f ldm lr, {r0, r1, r2, r3} <== NOT EXECUTED
3606c: e88c000f stm ip, {r0, r1, r2, r3} <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
memcpy(MSDOS_DIR_NAME(DOT_NODE_P(dot_dotdot)), MSDOS_DOT_NAME,
36070: e59f31dc ldr r3, [pc, #476] ; 36254 <msdos_creat_node+0x388><== NOT EXECUTED 36074: e3a0200b mov r2, #11 <== NOT EXECUTED 36078: e5931000 ldr r1, [r3] <== NOT EXECUTED 3607c: e1a00009 mov r0, r9 <== NOT EXECUTED 36080: eb00408a bl 462b0 <memcpy> <== NOT EXECUTED
MSDOS_NAME_MAX);
memcpy(MSDOS_DIR_NAME(DOTDOT_NODE_P(dot_dotdot)), MSDOS_DOTDOT_NAME,
36084: e59f31cc ldr r3, [pc, #460] ; 36258 <msdos_creat_node+0x38c><== NOT EXECUTED 36088: e1a00005 mov r0, r5 <== NOT EXECUTED 3608c: e5931000 ldr r1, [r3] <== NOT EXECUTED 36090: e3a0200b mov r2, #11 <== NOT EXECUTED 36094: eb004085 bl 462b0 <memcpy> <== NOT EXECUTED
/*
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
36098: e59de00c ldr lr, [sp, #12] <== NOT EXECUTED 3609c: e59e3020 ldr r3, [lr, #32] <== NOT EXECUTED 360a0: e3530001 cmp r3, #1 <== NOT EXECUTED 360a4: 0a00002c beq 3615c <msdos_creat_node+0x290> <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
360a8: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 360ac: e592301c ldr r3, [r2, #28] <== NOT EXECUTED
CT_LE_W((uint16_t )((parent_fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) =
360b0: e1a02823 lsr r2, r3, #16 <== NOT EXECUTED 360b4: e1cd24b8 strh r2, [sp, #72] ; 0x48 <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
}
else
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) =
360b8: e1cd34be strh r3, [sp, #78] ; 0x4e <== NOT EXECUTED
/*
* write dot and dotdot entries to new fat-file: currently fat-file
* correspondes to a new node is zero length, so it will be extended
* by one cluster and entries will be written
*/
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
360bc: e5960010 ldr r0, [r6, #16] <== NOT EXECUTED 360c0: e59d10a4 ldr r1, [sp, #164] ; 0xa4 <== NOT EXECUTED 360c4: e3a02000 mov r2, #0 <== NOT EXECUTED 360c8: e3a03040 mov r3, #64 ; 0x40 <== NOT EXECUTED 360cc: e58d9000 str r9, [sp] <== NOT EXECUTED 360d0: ebffbd87 bl 256f4 <fat_file_write> <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE * 2,
(uint8_t *)dot_dotdot);
if (ret < 0)
360d4: e3500000 cmp r0, #0 <== NOT EXECUTED 360d8: ba00001d blt 36154 <msdos_creat_node+0x288> <== NOT EXECUTED
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
360dc: e59d10a4 ldr r1, [sp, #164] ; 0xa4 <== NOT EXECUTED 360e0: e59de010 ldr lr, [sp, #16] <== NOT EXECUTED 360e4: e5912018 ldr r2, [r1, #24] <== NOT EXECUTED 360e8: e1de30b6 ldrh r3, [lr, #6] <== NOT EXECUTED
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
360ec: e591c01c ldr ip, [r1, #28] <== NOT EXECUTED
rc = -1;
goto error;
}
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
360f0: e0823003 add r3, r2, r3 <== NOT EXECUTED 360f4: e5813018 str r3, [r1, #24] <== NOT EXECUTED
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
360f8: e5960010 ldr r0, [r6, #16] <== NOT EXECUTED
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
360fc: e1a0e82c lsr lr, ip, #16 <== NOT EXECUTED
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
36100: e3a02000 mov r2, #0 <== NOT EXECUTED 36104: e3a03020 mov r3, #32 <== NOT EXECUTED
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
36108: e1cde2b8 strh lr, [sp, #40] ; 0x28 <== NOT EXECUTED
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
3610c: e58d9000 str r9, [sp] <== NOT EXECUTED
/* increment fat-file size by cluster size */
fat_fd->fat_file_size += fs_info->fat.vol.bpc;
/* set up cluster num for dot entry */
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOT_NODE_P(dot_dotdot)) =
36110: e1cdc2be strh ip, [sp, #46] ; 0x2e <== NOT EXECUTED
CT_LE_W((uint16_t )((fat_fd->cln) & 0x0000FFFF));
*MSDOS_DIR_FIRST_CLUSTER_HI(DOT_NODE_P(dot_dotdot)) =
CT_LE_W((uint16_t )(((fat_fd->cln) & 0xFFFF0000) >> 16));
/* rewrite dot entry */
ret = fat_file_write(parent_loc->mt_entry, fat_fd, 0,
36114: ebffbd76 bl 256f4 <fat_file_write> <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
(uint8_t *)DOT_NODE_P(dot_dotdot));
if (ret < 0)
36118: e3500000 cmp r0, #0 <== NOT EXECUTED 3611c: ba00000c blt 36154 <msdos_creat_node+0x288> <== NOT EXECUTED
rc = -1;
goto error;
}
/* write first cluster num of a new directory to disk */
rc = msdos_set_first_cluster_num(parent_loc->mt_entry, fat_fd);
36120: e5960010 ldr r0, [r6, #16] <== NOT EXECUTED 36124: e59d10a4 ldr r1, [sp, #164] ; 0xa4 <== NOT EXECUTED 36128: eb000695 bl 37b84 <msdos_set_first_cluster_num> <== NOT EXECUTED
if (rc != RC_OK)
3612c: e2507000 subs r7, r0, #0 <== NOT EXECUTED 36130: 0a000043 beq 36244 <msdos_creat_node+0x378> <== NOT EXECUTED
fat_file_close(parent_loc->mt_entry, fat_fd);
}
return RC_OK;
error:
fat_file_close(parent_loc->mt_entry, fat_fd);
36134: e5960010 ldr r0, [r6, #16] <== NOT EXECUTED 36138: e59d10a4 ldr r1, [sp, #164] ; 0xa4 <== NOT EXECUTED 3613c: ebffbe85 bl 25b58 <fat_file_close> <== NOT EXECUTED
err:
/* mark the used 32bytes structure on the disk as free */
msdos_set_first_char4file_name(parent_loc->mt_entry, &dir_pos, 0xE5);
36140: e5960010 ldr r0, [r6, #16] <== NOT EXECUTED 36144: e1a01004 mov r1, r4 <== NOT EXECUTED 36148: e3a020e5 mov r2, #229 ; 0xe5 <== NOT EXECUTED 3614c: eb0006bb bl 37c40 <msdos_set_first_char4file_name> <== NOT EXECUTED
return rc;
36150: eaffffa6 b 35ff0 <msdos_creat_node+0x124> <== NOT EXECUTED
/* write first cluster num of a new directory to disk */
rc = msdos_set_first_cluster_num(parent_loc->mt_entry, fat_fd);
if (rc != RC_OK)
goto error;
fat_file_close(parent_loc->mt_entry, fat_fd);
36154: e3e07000 mvn r7, #0 <== NOT EXECUTED 36158: eafffff5 b 36134 <msdos_creat_node+0x268> <== NOT EXECUTED
/*
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
3615c: e59e3024 ldr r3, [lr, #36] ; 0x24 <== NOT EXECUTED 36160: e3530000 cmp r3, #0 <== NOT EXECUTED 36164: 1affffcf bne 360a8 <msdos_creat_node+0x1dc> <== NOT EXECUTED
(fs_info->fat.vol.type & FAT_FAT32))
36168: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 3616c: e5d1200a ldrb r2, [r1, #10] <== NOT EXECUTED 36170: e3120004 tst r2, #4 <== NOT EXECUTED
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
*MSDOS_DIR_FIRST_CLUSTER_HI(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
36174: 11c933b4 strhne r3, [r9, #52] ; 0x34 <== NOT EXECUTED
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
(fs_info->fat.vol.type & FAT_FAT32))
{
*MSDOS_DIR_FIRST_CLUSTER_LOW(DOTDOT_NODE_P(dot_dotdot)) = 0x0000;
36178: 11c933ba strhne r3, [r9, #58] ; 0x3a <== NOT EXECUTED
* here we can ommit FAT32 condition because for all FAT types dirs
* right under root dir should contain 0 in dotdot entry but for
* FAT12/16 parent_fat_fd->cluster_num always contains such value
*/
if ((FAT_FD_OF_ROOT_DIR(parent_fat_fd)) &&
(fs_info->fat.vol.type & FAT_FAT32))
3617c: 1affffce bne 360bc <msdos_creat_node+0x1f0> <== NOT EXECUTED 36180: eaffffc8 b 360a8 <msdos_creat_node+0x1dc> <== NOT EXECUTED
* node to the newly created
*/
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
36184: e59d30d4 ldr r3, [sp, #212] ; 0xd4 <== NOT EXECUTED 36188: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED 3618c: e5960010 ldr r0, [r6, #16] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
36190: e3520000 cmp r2, #0 <== NOT EXECUTED
fat_cluster_num_to_sector_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
36194: e5903034 ldr r3, [r0, #52] ; 0x34 <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
36198: 1a000003 bne 361ac <msdos_creat_node+0x2e0> <== NOT EXECUTED 3619c: e5d3100a ldrb r1, [r3, #10] <== NOT EXECUTED 361a0: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
361a4: 1593c01c ldrne ip, [r3, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
361a8: 1a000003 bne 361bc <msdos_creat_node+0x2f0> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
361ac: e5931030 ldr r1, [r3, #48] ; 0x30 <== NOT EXECUTED 361b0: e5d33005 ldrb r3, [r3, #5] <== NOT EXECUTED 361b4: e2422002 sub r2, r2, #2 <== NOT EXECUTED 361b8: e081c312 add ip, r1, r2, lsl r3 <== NOT EXECUTED
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(parent_loc->mt_entry,
361bc: e59de010 ldr lr, [sp, #16] <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
361c0: e59d10d4 ldr r1, [sp, #212] ; 0xd4 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(parent_loc->mt_entry,
361c4: e1de20b0 ldrh r2, [lr] <== NOT EXECUTED
/*
* read the original directory entry
*/
sec = fat_cluster_num_to_sector_num(parent_loc->mt_entry,
link_fd->dir_pos.sname.cln);
sec += (link_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
361c8: e5913024 ldr r3, [r1, #36] ; 0x24 <== NOT EXECUTED
byte = (link_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
ret = _fat_block_read(parent_loc->mt_entry,
361cc: e5de1002 ldrb r1, [lr, #2] <== NOT EXECUTED 361d0: e2422001 sub r2, r2, #1 <== NOT EXECUTED 361d4: e08c1133 add r1, ip, r3, lsr r1 <== NOT EXECUTED 361d8: e0022003 and r2, r2, r3 <== NOT EXECUTED 361dc: e28dc054 add ip, sp, #84 ; 0x54 <== NOT EXECUTED 361e0: e3a03020 mov r3, #32 <== NOT EXECUTED 361e4: e58dc000 str ip, [sp] <== NOT EXECUTED 361e8: ebffc116 bl 26648 <_fat_block_read> <== NOT EXECUTED
sec, byte, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE,
link_node);
if (ret < 0) {
361ec: e3500000 cmp r0, #0 <== NOT EXECUTED 361f0: baffff81 blt 35ffc <msdos_creat_node+0x130> <== NOT EXECUTED
return -1;
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
361f4: e5dd305f ldrb r3, [sp, #95] ; 0x5f <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
361f8: e5dd2061 ldrb r2, [sp, #97] ; 0x61 <== NOT EXECUTED
return -1;
}
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
361fc: e5cd307f strb r3, [sp, #127] ; 0x7f <== NOT EXECUTED
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
36200: e5cd2081 strb r2, [sp, #129] ; 0x81 <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
36204: e59d2070 ldr r2, [sp, #112] ; 0x70 <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
36208: e5dd307f ldrb r3, [sp, #127] ; 0x7f <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
3620c: e585201c str r2, [r5, #28] <== NOT EXECUTED
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
36210: e1dd26b2 ldrh r2, [sp, #98] ; 0x62 <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
*MSDOS_DIR_FIRST_CLUSTER_HI(link_node);
/*
* set "archive bit" due to changes
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
36214: e3833020 orr r3, r3, #32 <== NOT EXECUTED 36218: e5cd307f strb r3, [sp, #127] ; 0x7f <== NOT EXECUTED
/*
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
3621c: e1cd28b2 strh r2, [sp, #130] ; 0x82 <== NOT EXECUTED
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
36220: e1dd36b4 ldrh r3, [sp, #100] ; 0x64 <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
36224: e1dde6be ldrh lr, [sp, #110] ; 0x6e <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
36228: e1dd16b8 ldrh r1, [sp, #104] ; 0x68 <== NOT EXECUTED
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
/*
* set "last access" date to today
*/
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
3622c: e1dd2ab8 ldrh r2, [sp, #168] ; 0xa8 <== NOT EXECUTED
* copy various attributes
*/
*MSDOS_DIR_ATTR(short_node) =*MSDOS_DIR_ATTR(link_node);
*MSDOS_DIR_CRT_TIME_TENTH(short_node)=*MSDOS_DIR_CRT_TIME_TENTH(link_node);
*MSDOS_DIR_CRT_TIME(short_node) =*MSDOS_DIR_CRT_TIME(link_node);
*MSDOS_DIR_CRT_DATE(short_node) =*MSDOS_DIR_CRT_DATE(link_node);
36230: e1cd38b4 strh r3, [sp, #132] ; 0x84 <== NOT EXECUTED
/*
* copy/set "file size", "first cluster"
*/
*MSDOS_DIR_FILE_SIZE(short_node) =*MSDOS_DIR_FILE_SIZE(link_node);
*MSDOS_DIR_FIRST_CLUSTER_LOW(short_node) =
36234: e1cde8be strh lr, [sp, #142] ; 0x8e <== NOT EXECUTED
*MSDOS_DIR_FIRST_CLUSTER_LOW(link_node);
*MSDOS_DIR_FIRST_CLUSTER_HI(short_node) =
36238: e1cd18b8 strh r1, [sp, #136] ; 0x88 <== NOT EXECUTED
*/
*MSDOS_DIR_ATTR(short_node) |= MSDOS_ATTR_ARCHIVE;
/*
* set "last access" date to today
*/
*MSDOS_DIR_LAST_ACCESS_DATE(short_node) = CT_LE_W(date);
3623c: e1cd28b6 strh r2, [sp, #134] ; 0x86 <== NOT EXECUTED 36240: eaffff5e b 35fc0 <msdos_creat_node+0xf4> <== NOT EXECUTED
/* write first cluster num of a new directory to disk */
rc = msdos_set_first_cluster_num(parent_loc->mt_entry, fat_fd);
if (rc != RC_OK)
goto error;
fat_file_close(parent_loc->mt_entry, fat_fd);
36244: e5960010 ldr r0, [r6, #16] <== NOT EXECUTED 36248: e59d10a4 ldr r1, [sp, #164] ; 0xa4 <== NOT EXECUTED 3624c: ebffbe41 bl 25b58 <fat_file_close> <== NOT EXECUTED 36250: eaffff66 b 35ff0 <msdos_creat_node+0x124> <== NOT EXECUTED
0004160c <msdos_date_dos2unix>:
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
4160c: e59f310c ldr r3, [pc, #268] ; 41720 <msdos_date_dos2unix+0x114><== NOT EXECUTED 41610: e1d320bc ldrh r2, [r3, #12] <== NOT EXECUTED 41614: e1520000 cmp r2, r0 <== NOT EXECUTED
* called from the stat(), and fstat() system calls and so probably need
* not be too efficient.
*/
unsigned int
msdos_date_dos2unix(unsigned int dd, unsigned int dt)
{
41618: e92d00f0 push {r4, r5, r6, r7} <== NOT EXECUTED
+ ((dt & MSDOS_DT_HOURS_MASK) >> MSDOS_DT_HOURS_SHIFT) * 3600;
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
4161c: 05932010 ldreq r2, [r3, #16] <== NOT EXECUTED 41620: 0a00002e beq 416e0 <msdos_date_dos2unix+0xd4> <== NOT EXECUTED
lastdosdate = dd; days = 0; year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
41624: e2005cfe and r5, r0, #65024 ; 0xfe00 <== NOT EXECUTED
for (y = 0; y < year; y++)
41628: e1b054a5 lsrs r5, r5, #9 <== NOT EXECUTED
/*
* If the year, month, and day from the last conversion are the
* same then use the saved value.
*/
if (lastdosdate != dd) {
lastdosdate = dd;
4162c: e1c300bc strh r0, [r3, #12] <== NOT EXECUTED
days = 0; year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT; for (y = 0; y < year; y++)
41630: 0a000037 beq 41714 <msdos_date_dos2unix+0x108> <== NOT EXECUTED 41634: e3a04f5b mov r4, #364 ; 0x16c <== NOT EXECUTED 41638: e2844002 add r4, r4, #2 <== NOT EXECUTED 4163c: e3a0c000 mov ip, #0 <== NOT EXECUTED
days += y & 0x03 ? 365 : 366;
41640: e3a06f5b mov r6, #364 ; 0x16c <== NOT EXECUTED 41644: e2866001 add r6, r6, #1 <== NOT EXECUTED
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
41648: e1a0200c mov r2, ip <== NOT EXECUTED
days += y & 0x03 ? 365 : 366;
4164c: e1a07004 mov r7, r4 <== NOT EXECUTED 41650: ea000002 b 41660 <msdos_date_dos2unix+0x54> <== NOT EXECUTED 41654: e31c0003 tst ip, #3 <== NOT EXECUTED 41658: 11a04006 movne r4, r6 <== NOT EXECUTED 4165c: 01a04007 moveq r4, r7 <== NOT EXECUTED
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
41660: e28cc001 add ip, ip, #1 <== NOT EXECUTED 41664: e155000c cmp r5, ip <== NOT EXECUTED
days += y & 0x03 ? 365 : 366;
41668: e0822004 add r2, r2, r4 <== NOT EXECUTED
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
4166c: 8afffff8 bhi 41654 <msdos_date_dos2unix+0x48> <== NOT EXECUTED
days += y & 0x03 ? 365 : 366; months = year & 0x03 ? regyear : leapyear;
41670: e59fc0ac ldr ip, [pc, #172] ; 41724 <msdos_date_dos2unix+0x118><== NOT EXECUTED 41674: e3150003 tst r5, #3 <== NOT EXECUTED 41678: e24c5018 sub r5, ip, #24 <== NOT EXECUTED 4167c: 11a0500c movne r5, ip <== NOT EXECUTED
/* * Prevent going from 0 to 0xffffffff in the following * loop. */ month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
41680: e2006e1e and r6, r0, #480 ; 0x1e0 <== NOT EXECUTED
if (month == 0) {
41684: e1b062a6 lsrs r6, r6, #5 <== NOT EXECUTED 41688: 0a000008 beq 416b0 <msdos_date_dos2unix+0xa4> <== NOT EXECUTED
month = 1; } for (m = 0; m < month - 1; m++)
4168c: e2566001 subs r6, r6, #1 <== NOT EXECUTED 41690: 0a000006 beq 416b0 <msdos_date_dos2unix+0xa4> <== NOT EXECUTED 41694: e3a0c000 mov ip, #0 <== NOT EXECUTED
days += months[m];
41698: e1a0408c lsl r4, ip, #1 <== NOT EXECUTED 4169c: e19540b4 ldrh r4, [r5, r4] <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
416a0: e28cc001 add ip, ip, #1 <== NOT EXECUTED 416a4: e15c0006 cmp ip, r6 <== NOT EXECUTED
days += months[m];
416a8: e0822004 add r2, r2, r4 <== NOT EXECUTED
*/
month = (dd & MSDOS_DD_MONTH_MASK) >> MSDOS_DD_MONTH_SHIFT;
if (month == 0) {
month = 1;
}
for (m = 0; m < month - 1; m++)
416ac: 3afffff9 bcc 41698 <msdos_date_dos2unix+0x8c> <== NOT EXECUTED
days += months[m]; days += ((dd & MSDOS_DD_DAY_MASK) >> MSDOS_DD_DAY_SHIFT) - 1; lastseconds = (days + DAYSTO1980) * SECONDSPERDAY;
416b0: e200001f and r0, r0, #31 <== NOT EXECUTED 416b4: e2400001 sub r0, r0, #1 <== NOT EXECUTED 416b8: e0802002 add r2, r0, r2 <== NOT EXECUTED 416bc: e0820102 add r0, r2, r2, lsl #2 <== NOT EXECUTED 416c0: e0820100 add r0, r2, r0, lsl #2 <== NOT EXECUTED 416c4: e0820200 add r0, r2, r0, lsl #4 <== NOT EXECUTED 416c8: e0822080 add r2, r2, r0, lsl #1 <== NOT EXECUTED 416cc: e1a02382 lsl r2, r2, #7 <== NOT EXECUTED 416d0: e282254b add r2, r2, #314572800 ; 0x12c00000 <== NOT EXECUTED 416d4: e2822aea add r2, r2, #958464 ; 0xea000 <== NOT EXECUTED 416d8: e2822c06 add r2, r2, #1536 ; 0x600 <== NOT EXECUTED 416dc: e5832010 str r2, [r3, #16] <== NOT EXECUTED 416e0: e2013b3e and r3, r1, #63488 ; 0xf800 <== NOT EXECUTED 416e4: e2010e7e and r0, r1, #2016 ; 0x7e0 <== NOT EXECUTED 416e8: e1a035a3 lsr r3, r3, #11 <== NOT EXECUTED 416ec: e0634183 rsb r4, r3, r3, lsl #3 <== NOT EXECUTED 416f0: e1a0c1a0 lsr ip, r0, #3 <== NOT EXECUTED 416f4: e0833284 add r3, r3, r4, lsl #5 <== NOT EXECUTED 416f8: e06c0080 rsb r0, ip, r0, lsl #1 <== NOT EXECUTED 416fc: e0800203 add r0, r0, r3, lsl #4 <== NOT EXECUTED 41700: e201101f and r1, r1, #31 <== NOT EXECUTED 41704: e0800001 add r0, r0, r1 <== NOT EXECUTED
} return seconds + lastseconds; }
41708: e0800002 add r0, r0, r2 <== NOT EXECUTED
4170c: e8bd00f0 pop {r4, r5, r6, r7} <== NOT EXECUTED
41710: e12fff1e bx lr <== NOT EXECUTED
*/
if (lastdosdate != dd) {
lastdosdate = dd;
days = 0;
year = (dd & MSDOS_DD_YEAR_MASK) >> MSDOS_DD_YEAR_SHIFT;
for (y = 0; y < year; y++)
41714: e1a02005 mov r2, r5 <== NOT EXECUTED 41718: e59f5008 ldr r5, [pc, #8] ; 41728 <msdos_date_dos2unix+0x11c><== NOT EXECUTED 4171c: eaffffd7 b 41680 <msdos_date_dos2unix+0x74> <== NOT EXECUTED
00041484 <msdos_date_unix2dos>:
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
41484: e59f316c ldr r3, [pc, #364] ; 415f8 <msdos_date_unix2dos+0x174><== NOT EXECUTED 41488: e593c000 ldr ip, [r3] <== NOT EXECUTED 4148c: e15c0000 cmp ip, r0 <== NOT EXECUTED
* file timestamps. The passed in unix time is assumed to be in GMT.
*/
void
msdos_date_unix2dos(unsigned int t, uint16_t *ddp,
uint16_t *dtp)
{
41490: e92d05f0 push {r4, r5, r6, r7, r8, sl} <== NOT EXECUTED
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
41494: 0a000054 beq 415ec <msdos_date_unix2dos+0x168> <== NOT EXECUTED
lasttime = t; lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
41498: e59fc15c ldr ip, [pc, #348] ; 415fc <msdos_date_unix2dos+0x178><== NOT EXECUTED 4149c: e59f415c ldr r4, [pc, #348] ; 41600 <msdos_date_unix2dos+0x17c><== NOT EXECUTED 414a0: e0856094 umull r6, r5, r4, r0 <== NOT EXECUTED 414a4: e084709c umull r7, r4, ip, r0 <== NOT EXECUTED 414a8: e1a042a4 lsr r4, r4, #5 <== NOT EXECUTED 414ac: e086849c umull r8, r6, ip, r4 <== NOT EXECUTED 414b0: e28cc422 add ip, ip, #570425344 ; 0x22000000 <== NOT EXECUTED 414b4: e28cc822 add ip, ip, #2228224 ; 0x220000 <== NOT EXECUTED 414b8: e28ccc22 add ip, ip, #8704 ; 0x2200 <== NOT EXECUTED 414bc: e1a055a5 lsr r5, r5, #11 <== NOT EXECUTED 414c0: e28cc022 add ip, ip, #34 ; 0x22 <== NOT EXECUTED 414c4: e087a59c umull sl, r7, ip, r5 <== NOT EXECUTED
/* * If the number of days since 1970 is the same as the last * time we did the computation then skip all this leap year * and month stuff. */ days = t / (SECONDSPERDAY);
414c8: e59f8134 ldr r8, [pc, #308] ; 41604 <msdos_date_unix2dos+0x180><== NOT EXECUTED 414cc: e08ca098 umull sl, ip, r8, r0 <== NOT EXECUTED
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
414d0: e1a062a6 lsr r6, r6, #5 <== NOT EXECUTED 414d4: e1a07227 lsr r7, r7, #4 <== NOT EXECUTED 414d8: e1a08306 lsl r8, r6, #6 <== NOT EXECUTED 414dc: e0877087 add r7, r7, r7, lsl #1 <== NOT EXECUTED 414e0: e0486106 sub r6, r8, r6, lsl #2 <== NOT EXECUTED 414e4: e0455187 sub r5, r5, r7, lsl #3 <== NOT EXECUTED 414e8: e1a08304 lsl r8, r4, #6 <== NOT EXECUTED 414ec: e0488104 sub r8, r8, r4, lsl #2 <== NOT EXECUTED 414f0: e1a05585 lsl r5, r5, #11 <== NOT EXECUTED 414f4: e0664004 rsb r4, r6, r4 <== NOT EXECUTED 414f8: e0854284 add r4, r5, r4, lsl #5 <== NOT EXECUTED 414fc: e0686000 rsb r6, r8, r0 <== NOT EXECUTED 41500: e08460a6 add r6, r4, r6, lsr #1 <== NOT EXECUTED
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
41504: e5935008 ldr r5, [r3, #8] <== NOT EXECUTED
/* * If the number of days since 1970 is the same as the last * time we did the computation then skip all this leap year * and month stuff. */ days = t / (SECONDSPERDAY);
41508: e1a0c82c lsr ip, ip, #16 <== NOT EXECUTED
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
4150c: e1a06806 lsl r6, r6, #16 <== NOT EXECUTED
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
41510: e15c0005 cmp ip, r5 <== NOT EXECUTED
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
41514: e1a06826 lsr r6, r6, #16 <== NOT EXECUTED
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
lasttime = t;
41518: e5830000 str r0, [r3] <== NOT EXECUTED
lastdtime = (((t % 60) >> 1) << MSDOS_DT_2SECONDS_SHIFT)
4151c: e1c360b4 strh r6, [r3, #4] <== NOT EXECUTED
* If the number of days since 1970 is the same as the last
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
41520: 01d3c0b6 ldrheq ip, [r3, #6] <== NOT EXECUTED 41524: 0a00002c beq 415dc <msdos_date_unix2dos+0x158> <== NOT EXECUTED
lastday = days;
for (year = 1970;; year++) {
inc = year & 0x03 ? 365 : 366;
41528: e3a07f5b mov r7, #364 ; 0x16c <== NOT EXECUTED 4152c: e1a05007 mov r5, r7 <== NOT EXECUTED
* time we did the computation then skip all this leap year
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
lastday = days;
41530: e3a00e7b mov r0, #1968 ; 0x7b0 <== NOT EXECUTED 41534: e583c008 str ip, [r3, #8] <== NOT EXECUTED 41538: e2800002 add r0, r0, #2 <== NOT EXECUTED
for (year = 1970;; year++) {
inc = year & 0x03 ? 365 : 366;
4153c: e2877001 add r7, r7, #1 <== NOT EXECUTED 41540: e2855002 add r5, r5, #2 <== NOT EXECUTED 41544: ea000001 b 41550 <msdos_date_unix2dos+0xcc> <== NOT EXECUTED
if (days < inc) break; days -= inc;
41548: e064c00c rsb ip, r4, ip <== NOT EXECUTED
* and month stuff.
*/
days = t / (SECONDSPERDAY);
if (days != lastday) {
lastday = days;
for (year = 1970;; year++) {
4154c: e2800001 add r0, r0, #1 <== NOT EXECUTED
inc = year & 0x03 ? 365 : 366;
41550: e2108003 ands r8, r0, #3 <== NOT EXECUTED 41554: 11a04007 movne r4, r7 <== NOT EXECUTED 41558: 01a04005 moveq r4, r5 <== NOT EXECUTED
if (days < inc)
4155c: e15c0004 cmp ip, r4 <== NOT EXECUTED 41560: 2afffff8 bcs 41548 <msdos_date_unix2dos+0xc4> <== NOT EXECUTED
break; days -= inc; } months = year & 0x03 ? regyear : leapyear;
41564: e59f409c ldr r4, [pc, #156] ; 41608 <msdos_date_unix2dos+0x184><== NOT EXECUTED 41568: e3580000 cmp r8, #0 <== NOT EXECUTED 4156c: e2445018 sub r5, r4, #24 <== NOT EXECUTED 41570: 11a08004 movne r8, r4 <== NOT EXECUTED 41574: 01a08005 moveq r8, r5 <== NOT EXECUTED 41578: e3a04000 mov r4, #0 <== NOT EXECUTED
for (month = 0; month < 12; month++) {
if (days < months[month])
4157c: e1a05084 lsl r5, r4, #1 <== NOT EXECUTED 41580: e19850b5 ldrh r5, [r8, r5] <== NOT EXECUTED 41584: e155000c cmp r5, ip <== NOT EXECUTED 41588: 8a000003 bhi 4159c <msdos_date_unix2dos+0x118> <== NOT EXECUTED
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
4158c: e2844001 add r4, r4, #1 <== NOT EXECUTED 41590: e354000c cmp r4, #12 <== NOT EXECUTED
if (days < months[month]) break; days -= months[month];
41594: e065c00c rsb ip, r5, ip <== NOT EXECUTED
if (days < inc)
break;
days -= inc;
}
months = year & 0x03 ? regyear : leapyear;
for (month = 0; month < 12; month++) {
41598: 1afffff7 bne 4157c <msdos_date_unix2dos+0xf8> <== NOT EXECUTED
if (days < months[month]) break; days -= months[month]; } lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
4159c: e08cc284 add ip, ip, r4, lsl #5 <== NOT EXECUTED 415a0: e28cc021 add ip, ip, #33 ; 0x21 <== NOT EXECUTED
* Remember dos's idea of time is relative to 1980. * unix's is relative to 1970. If somehow we get a * time before 1980 then don't give totally crazy * results. */ if (year > 1980)
415a4: e3a05e7b mov r5, #1968 ; 0x7b0 <== NOT EXECUTED
for (month = 0; month < 12; month++) {
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
415a8: e1a0c80c lsl ip, ip, #16 <== NOT EXECUTED
* Remember dos's idea of time is relative to 1980. * unix's is relative to 1970. If somehow we get a * time before 1980 then don't give totally crazy * results. */ if (year > 1980)
415ac: e285500c add r5, r5, #12 <== NOT EXECUTED
for (month = 0; month < 12; month++) {
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
415b0: e1a0c82c lsr ip, ip, #16 <== NOT EXECUTED
* Remember dos's idea of time is relative to 1980. * unix's is relative to 1970. If somehow we get a * time before 1980 then don't give totally crazy * results. */ if (year > 1980)
415b4: e1500005 cmp r0, r5 <== NOT EXECUTED
for (month = 0; month < 12; month++) {
if (days < months[month])
break;
days -= months[month];
}
lastddate = ((days + 1) << MSDOS_DD_DAY_SHIFT)
415b8: e1c3c0b6 strh ip, [r3, #6] <== NOT EXECUTED
* Remember dos's idea of time is relative to 1980. * unix's is relative to 1970. If somehow we get a * time before 1980 then don't give totally crazy * results. */ if (year > 1980)
415bc: 9a000006 bls 415dc <msdos_date_unix2dos+0x158> <== NOT EXECUTED
lastddate += (year - 1980) <<
415c0: e2400e7b sub r0, r0, #1968 ; 0x7b0 <== NOT EXECUTED 415c4: e240000c sub r0, r0, #12 <== NOT EXECUTED 415c8: e08cc480 add ip, ip, r0, lsl #9 <== NOT EXECUTED 415cc: e1a0c80c lsl ip, ip, #16 <== NOT EXECUTED 415d0: e59f3020 ldr r3, [pc, #32] ; 415f8 <msdos_date_unix2dos+0x174><== NOT EXECUTED 415d4: e1a0c82c lsr ip, ip, #16 <== NOT EXECUTED 415d8: e1c3c0b6 strh ip, [r3, #6] <== NOT EXECUTED
MSDOS_DD_YEAR_SHIFT; } } *dtp = lastdtime;
415dc: e1c260b0 strh r6, [r2] <== NOT EXECUTED
*ddp = lastddate;
415e0: e1c1c0b0 strh ip, [r1] <== NOT EXECUTED
}
415e4: e8bd05f0 pop {r4, r5, r6, r7, r8, sl} <== NOT EXECUTED
415e8: e12fff1e bx lr <== NOT EXECUTED
/*
* If the time from the last conversion is the same as now, then
* skip the computations and use the saved result.
*/
if (lasttime != t) {
415ec: e1d3c0b6 ldrh ip, [r3, #6] <== NOT EXECUTED 415f0: e1d360b4 ldrh r6, [r3, #4] <== NOT EXECUTED 415f4: eafffff8 b 415dc <msdos_date_unix2dos+0x158> <== NOT EXECUTED
0004190c <msdos_dir_chmod>:
int
msdos_dir_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
return RC_OK;
}
4190c: e3a00000 mov r0, #0 <== NOT EXECUTED 41910: e12fff1e bx lr <== NOT EXECUTED
00042164 <msdos_dir_close>:
int
msdos_dir_close(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
42164: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
* RC_OK, if directory closed successfully, or -1 if error occured (errno
* set apropriately.
*/
int
msdos_dir_close(rtems_libio_t *iop)
{
42168: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
4216c: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
42170: e3a01000 mov r1, #0 <== NOT EXECUTED
* RC_OK, if directory closed successfully, or -1 if error occured (errno
* set apropriately.
*/
int
msdos_dir_close(rtems_libio_t *iop)
{
42174: e1a04000 mov r4, r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
42178: e1a02001 mov r2, r1 <== NOT EXECUTED 4217c: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
msdos_dir_close(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
42180: e5946038 ldr r6, [r4, #56] ; 0x38 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
42184: ebff28ce bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
42188: e3500000 cmp r0, #0 <== NOT EXECUTED 4218c: 1a000007 bne 421b0 <msdos_dir_close+0x4c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
42190: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 42194: e1a01006 mov r1, r6 <== NOT EXECUTED 42198: ebff8e6e bl 25b58 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
4219c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rtems_semaphore_release(fs_info->vol_sema);
421a0: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED 421a4: ebff290e bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
}
421a8: e1a00004 mov r0, r4 <== NOT EXECUTED
421ac: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one( EIO );
421b0: eb00038e bl 42ff0 <__errno> <== NOT EXECUTED 421b4: e3a03005 mov r3, #5 <== NOT EXECUTED 421b8: e5803000 str r3, [r0] <== NOT EXECUTED 421bc: e3e04000 mvn r4, #0 <== NOT EXECUTED 421c0: eafffff8 b 421a8 <msdos_dir_close+0x44> <== NOT EXECUTED
000379b4 <msdos_dir_is_empty>:
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
379b4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
379b8: e5909034 ldr r9, [r0, #52] ; 0x34 <== NOT EXECUTED
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
379bc: e24dd010 sub sp, sp, #16 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
379c0: e3a03000 mov r3, #0 <== NOT EXECUTED
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
379c4: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 379c8: e58d100c str r1, [sp, #12] <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
379cc: e5c23000 strb r3, [r2] <== NOT EXECUTED 379d0: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 379d4: e1d940b0 ldrh r4, [r9] <== NOT EXECUTED 379d8: e5995098 ldr r5, [r9, #152] ; 0x98 <== NOT EXECUTED
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
379dc: e59f6110 ldr r6, [pc, #272] ; 37af4 <msdos_dir_is_empty+0x140><== NOT EXECUTED
msdos_dir_is_empty(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd,
bool *ret_val
)
{
379e0: e1a0b000 mov fp, r0 <== NOT EXECUTED
uint32_t j = 0, i = 0;
/* dir is not empty */
*ret_val = false;
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
379e4: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 379e8: e1a03004 mov r3, r4 <== NOT EXECUTED 379ec: e1a0000b mov r0, fp <== NOT EXECUTED 379f0: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 379f4: e0020294 mul r2, r4, r2 <== NOT EXECUTED 379f8: e58d5000 str r5, [sp] <== NOT EXECUTED 379fc: ebffb7d2 bl 2594c <fat_file_read> <== NOT EXECUTED 37a00: e3500000 cmp r0, #0 <== NOT EXECUTED 37a04: 0a00002e beq 37ac4 <msdos_dir_is_empty+0x110> <== NOT EXECUTED
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
37a08: e350001f cmp r0, #31 <== NOT EXECUTED 37a0c: da000030 ble 37ad4 <msdos_dir_is_empty+0x120> <== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
37a10: e1d940b0 ldrh r4, [r9] <== NOT EXECUTED 37a14: e1500004 cmp r0, r4 <== NOT EXECUTED 37a18: 1a00002f bne 37adc <msdos_dir_is_empty+0x128> <== NOT EXECUTED
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
37a1c: e3540000 cmp r4, #0 <== NOT EXECUTED 37a20: 0a000025 beq 37abc <msdos_dir_is_empty+0x108> <== NOT EXECUTED
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
return -1;
assert(ret == fs_info->fat.vol.bps);
37a24: e5995098 ldr r5, [r9, #152] ; 0x98 <== NOT EXECUTED 37a28: e3a07000 mov r7, #0 <== NOT EXECUTED 37a2c: e1a08005 mov r8, r5 <== NOT EXECUTED
* then consider it as empty.
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
37a30: e7d5a007 ldrb sl, [r5, r7] <== NOT EXECUTED 37a34: e35a00e5 cmp sl, #229 ; 0xe5 <== NOT EXECUTED 37a38: 0a000017 beq 37a9c <msdos_dir_is_empty+0xe8> <== NOT EXECUTED 37a3c: e5d8300b ldrb r3, [r8, #11] <== NOT EXECUTED 37a40: e203303f and r3, r3, #63 ; 0x3f <== NOT EXECUTED 37a44: e353000f cmp r3, #15 <== NOT EXECUTED 37a48: 0a000013 beq 37a9c <msdos_dir_is_empty+0xe8> <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
37a4c: e1a00008 mov r0, r8 <== NOT EXECUTED 37a50: e5961000 ldr r1, [r6] <== NOT EXECUTED 37a54: e3a0200b mov r2, #11 <== NOT EXECUTED 37a58: eb0048ab bl 49d0c <strncmp> <== NOT EXECUTED
* then consider it as empty.
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
37a5c: e3500000 cmp r0, #0 <== NOT EXECUTED 37a60: 0a00000d beq 37a9c <msdos_dir_is_empty+0xe8> <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY) ||
((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
MSDOS_ATTR_LFN) ||
(strncmp(MSDOS_DIR_NAME((entry)), MSDOS_DOT_NAME,
MSDOS_SHORT_NAME_LEN) == 0) ||
(strncmp(MSDOS_DIR_NAME((entry)),
37a64: e1a00008 mov r0, r8 <== NOT EXECUTED 37a68: e5961004 ldr r1, [r6, #4] <== NOT EXECUTED 37a6c: e3a0200b mov r2, #11 <== NOT EXECUTED 37a70: eb0048a5 bl 49d0c <strncmp> <== NOT EXECUTED
* then consider it as empty.
*
* Just ignore long file name entries. They must have a short entry to
* be valid.
*/
if (((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
37a74: e3500000 cmp r0, #0 <== NOT EXECUTED 37a78: 0a000007 beq 37a9c <msdos_dir_is_empty+0xe8> <== NOT EXECUTED
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
37a7c: e35a0000 cmp sl, #0 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
37a80: 059d2008 ldreq r2, [sp, #8] <== NOT EXECUTED 37a84: 03a03001 moveq r3, #1 <== NOT EXECUTED 37a88: 05c23000 strbeq r3, [r2] <== NOT EXECUTED
continue;
/*
* Nothing more to look at.
*/
if ((*MSDOS_DIR_NAME(entry)) ==
37a8c: 13a00000 movne r0, #0 <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
37a90: 01a0000a moveq r0, sl <== NOT EXECUTED
}
j++;
}
*ret_val = true;
return RC_OK;
}
37a94: e28dd010 add sp, sp, #16 <== NOT EXECUTED
37a98: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
i < fs_info->fat.vol.bps;
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
37a9c: e2877020 add r7, r7, #32 <== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
37aa0: e1570004 cmp r7, r4 <== NOT EXECUTED
i < fs_info->fat.vol.bps;
i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
37aa4: e2888020 add r8, r8, #32 <== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (i = 0;
37aa8: 3affffe0 bcc 37a30 <msdos_dir_is_empty+0x7c> <== NOT EXECUTED
/*
* Short file name entries mean not empty.
*/
return RC_OK;
}
j++;
37aac: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 37ab0: e2833001 add r3, r3, #1 <== NOT EXECUTED 37ab4: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 37ab8: eaffffc9 b 379e4 <msdos_dir_is_empty+0x30> <== NOT EXECUTED
*/
if ((*MSDOS_DIR_NAME(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
*ret_val = true;
return RC_OK;
37abc: e5995098 ldr r5, [r9, #152] ; 0x98 <== NOT EXECUTED 37ac0: eafffff9 b 37aac <msdos_dir_is_empty+0xf8> <== NOT EXECUTED
*/
return RC_OK;
}
j++;
}
*ret_val = true;
37ac4: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 37ac8: e3a03001 mov r3, #1 <== NOT EXECUTED 37acc: e5c23000 strb r3, [r2] <== NOT EXECUTED
return RC_OK;
37ad0: eaffffef b 37a94 <msdos_dir_is_empty+0xe0> <== NOT EXECUTED
while ((ret = fat_file_read(mt_entry, fat_fd, j * fs_info->fat.vol.bps,
fs_info->fat.vol.bps,
fs_info->cl_buf)) != FAT_EOF)
{
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
37ad4: e3e00000 mvn r0, #0 <== NOT EXECUTED 37ad8: eaffffed b 37a94 <msdos_dir_is_empty+0xe0> <== NOT EXECUTED
return -1;
assert(ret == fs_info->fat.vol.bps);
37adc: e3a01fed mov r1, #948 ; 0x3b4 <== NOT EXECUTED 37ae0: e2811001 add r1, r1, #1 <== NOT EXECUTED 37ae4: e59f000c ldr r0, [pc, #12] ; 37af8 <msdos_dir_is_empty+0x144><== NOT EXECUTED 37ae8: e59f200c ldr r2, [pc, #12] ; 37afc <msdos_dir_is_empty+0x148><== NOT EXECUTED 37aec: e59f300c ldr r3, [pc, #12] ; 37b00 <msdos_dir_is_empty+0x14c><== NOT EXECUTED 37af0: ebffc38b bl 28924 <__assert_func> <== NOT EXECUTED
00041914 <msdos_dir_lseek>:
* set apropriately).
*/
rtems_off64_t
msdos_dir_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
switch (whence)
41914: e3530001 cmp r3, #1 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno
* set apropriately).
*/
rtems_off64_t
msdos_dir_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
41918: e92d4010 push {r4, lr} <== NOT EXECUTED
switch (whence)
4191c: 93a03000 movls r3, #0 <== NOT EXECUTED 41920: 93a04000 movls r4, #0 <== NOT EXECUTED 41924: 9a000004 bls 4193c <msdos_dir_lseek+0x28> <== NOT EXECUTED
* Movement past the end of the directory via lseek is not a
* permitted operation
*/
case SEEK_END:
default:
rtems_set_errno_and_return_minus_one( EINVAL );
41928: eb0005b0 bl 42ff0 <__errno> <== NOT EXECUTED 4192c: e3a03016 mov r3, #22 <== NOT EXECUTED 41930: e5803000 str r3, [r0] <== NOT EXECUTED 41934: e3e04000 mvn r4, #0 <== NOT EXECUTED 41938: e3e03000 mvn r3, #0 <== NOT EXECUTED
break;
}
return RC_OK;
}
4193c: e1a01004 mov r1, r4 <== NOT EXECUTED
41940: e1a00003 mov r0, r3 <== NOT EXECUTED
41944: e8bd8010 pop {r4, pc} <== NOT EXECUTED
000421c4 <msdos_dir_open>:
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
421c4: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
* set apropriately)
*/
int
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
421c8: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
421cc: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
421d0: e3a01000 mov r1, #0 <== NOT EXECUTED
* set apropriately)
*/
int
msdos_dir_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
421d4: e1a04000 mov r4, r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
421d8: e1a02001 mov r2, r1 <== NOT EXECUTED 421dc: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
uint32_t mode)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
421e0: e5946038 ldr r6, [r4, #56] ; 0x38 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
421e4: ebff28b6 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
421e8: e3500000 cmp r0, #0 <== NOT EXECUTED 421ec: 1a00000a bne 4221c <msdos_dir_open+0x58> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
rc = fat_file_reopen(fat_fd);
421f0: e1a00006 mov r0, r6 <== NOT EXECUTED 421f4: ebff8b87 bl 25018 <fat_file_reopen> <== NOT EXECUTED
if (rc != RC_OK)
421f8: e2506000 subs r6, r0, #0 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
iop->offset = 0;
421fc: 03a02000 moveq r2, #0 <== NOT EXECUTED 42200: 03a03000 moveq r3, #0 <== NOT EXECUTED 42204: 0584200c streq r2, [r4, #12] <== NOT EXECUTED 42208: 05843010 streq r3, [r4, #16] <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
4220c: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED 42210: ebff28f3 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
}
42214: e1a00006 mov r0, r6 <== NOT EXECUTED
42218: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one( EIO );
4221c: eb000373 bl 42ff0 <__errno> <== NOT EXECUTED 42220: e3a03005 mov r3, #5 <== NOT EXECUTED 42224: e5803000 str r3, [r0] <== NOT EXECUTED 42228: e3e06000 mvn r6, #0 <== NOT EXECUTED 4222c: eafffff8 b 42214 <msdos_dir_open+0x50> <== NOT EXECUTED
00041b48 <msdos_dir_read>:
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
41b48: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
41b4c: e5903038 ldr r3, [r0, #56] ; 0x38 <== NOT EXECUTED
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
41b50: e24dde16 sub sp, sp, #352 ; 0x160 <== NOT EXECUTED 41b54: e1a0a000 mov sl, r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
41b58: e58d3024 str r3, [sp, #36] ; 0x24 <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
41b5c: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
41b60: e59a3028 ldr r3, [sl, #40] ; 0x28 <== NOT EXECUTED 41b64: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
41b68: e3500001 cmp r0, #1 <== NOT EXECUTED
* the number of bytes read on success, or -1 if error occured (errno
* set apropriately).
*/
ssize_t
msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
{
41b6c: e58d102c str r1, [sp, #44] ; 0x2c <== NOT EXECUTED 41b70: e1a04002 mov r4, r2 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
41b74: e58d300c str r3, [sp, #12] <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
41b78: e28a600c add r6, sl, #12 <== NOT EXECUTED
41b7c: e8960060 ldm r6, {r5, r6} <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
41b80: 0a00011d beq 41ffc <msdos_dir_read+0x4b4> <== NOT EXECUTED 41b84: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 41b88: e1d330b6 ldrh r3, [r3, #6] <== NOT EXECUTED 41b8c: e58d3030 str r3, [sp, #48] ; 0x30 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
41b90: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED
uint32_t start = 0;
ssize_t ret = 0;
uint32_t cmpltd = 0;
uint32_t j = 0, i = 0;
uint32_t bts2rd = 0;
uint32_t cur_cln = 0;
41b94: e3a03000 mov r3, #0 <== NOT EXECUTED
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
41b98: e59c0094 ldr r0, [ip, #148] ; 0x94 <== NOT EXECUTED 41b9c: e1a01003 mov r1, r3 <== NOT EXECUTED 41ba0: e1a02003 mov r2, r3 <== NOT EXECUTED
uint32_t start = 0;
ssize_t ret = 0;
uint32_t cmpltd = 0;
uint32_t j = 0, i = 0;
uint32_t bts2rd = 0;
uint32_t cur_cln = 0;
41ba4: e58d3158 str r3, [sp, #344] ; 0x158 <== NOT EXECUTED
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
fat_file_fd_t *tmp_fat_fd = NULL;
41ba8: e58d315c str r3, [sp, #348] ; 0x15c <== NOT EXECUTED
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
fat_fd->fat_file_size :
fs_info->fat.vol.bpc;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
41bac: ebff2a44 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
41bb0: e250c000 subs ip, r0, #0 <== NOT EXECUTED 41bb4: 1a000161 bne 42140 <msdos_dir_read+0x5f8> <== NOT EXECUTED
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
count = (count / sizeof(struct dirent)) * sizeof(struct dirent);
41bb8: e59f259c ldr r2, [pc, #1436] ; 4215c <msdos_dir_read+0x614><== NOT EXECUTED 41bbc: e0831492 umull r1, r3, r2, r4 <== NOT EXECUTED 41bc0: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED 41bc4: e0833203 add r3, r3, r3, lsl #4 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
while (count > 0)
41bc8: e1b03203 lsls r3, r3, #4 <== NOT EXECUTED 41bcc: e58d3018 str r3, [sp, #24] <== NOT EXECUTED 41bd0: 0a00015f beq 42154 <msdos_dir_read+0x60c> <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
41bd4: e1a01006 mov r1, r6 <== NOT EXECUTED 41bd8: e3a02e11 mov r2, #272 ; 0x110 <== NOT EXECUTED 41bdc: e3a03000 mov r3, #0 <== NOT EXECUTED 41be0: e1a00005 mov r0, r5 <== NOT EXECUTED 41be4: e58dc014 str ip, [sp, #20] <== NOT EXECUTED 41be8: eb00665e bl 5b568 <__divdi3> <== NOT EXECUTED 41bec: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 41bf0: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
41bf4: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 41bf8: e2811010 add r1, r1, #16 <== NOT EXECUTED 41bfc: e592c098 ldr ip, [r2, #152] ; 0x98 <== NOT EXECUTED 41c00: e59f8558 ldr r8, [pc, #1368] ; 42160 <msdos_dir_read+0x618><== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
41c04: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 41c08: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
41c0c: e58d1034 str r1, [sp, #52] ; 0x34 <== NOT EXECUTED
/*
* cast start and count - protect against using sizes that are not exact
* multiples of the -dirent- size. These could result in unexpected
* results
*/
start = iop->offset / sizeof(struct dirent);
41c10: e1a06000 mov r6, r0 <== NOT EXECUTED 41c14: e1a0b003 mov fp, r3 <== NOT EXECUTED 41c18: e3e09000 mvn r9, #0 <== NOT EXECUTED
* fat-file is already opened by open call, so read it
* Always read directory fat-file from the beggining because of MSDOS
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
41c1c: e59a0028 ldr r0, [sl, #40] ; 0x28 <== NOT EXECUTED 41c20: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 41c24: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 41c28: e59d3030 ldr r3, [sp, #48] ; 0x30 <== NOT EXECUTED 41c2c: e58dc000 str ip, [sp] <== NOT EXECUTED 41c30: ebff8f45 bl 2594c <fat_file_read> <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
41c34: e350001f cmp r0, #31 <== NOT EXECUTED
* fat-file is already opened by open call, so read it
* Always read directory fat-file from the beggining because of MSDOS
* directories feature :( - we should count elements currently
* present in the directory because there may be holes :)
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
41c38: e1a07000 mov r7, r0 <== NOT EXECUTED
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
41c3c: da00013c ble 42134 <msdos_dir_read+0x5ec> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
41c40: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 41c44: e592c098 ldr ip, [r2, #152] ; 0x98 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
41c48: e5dc3000 ldrb r3, [ip] <== NOT EXECUTED 41c4c: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
41c50: e1a0500c mov r5, ip <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
41c54: 0a0000c0 beq 41f5c <msdos_dir_read+0x414> <== NOT EXECUTED
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
41c58: e3a014b9 mov r1, #-1191182336 ; 0xb9000000 <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
41c5c: e3e02f46 mvn r2, #280 ; 0x118 <== NOT EXECUTED
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
41c60: e1a01b41 asr r1, r1, #22 <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
41c64: e2422001 sub r2, r2, #1 <== NOT EXECUTED
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
41c68: e58d101c str r1, [sp, #28] <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
41c6c: e58d2028 str r2, [sp, #40] ; 0x28 <== NOT EXECUTED
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
41c70: e3a04000 mov r4, #0 <== NOT EXECUTED 41c74: ea000009 b 41ca0 <msdos_dir_read+0x158> <== NOT EXECUTED
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
41c78: e202203f and r2, r2, #63 ; 0x3f <== NOT EXECUTED 41c7c: e352000f cmp r2, #15 <== NOT EXECUTED 41c80: 0a00008a beq 41eb0 <msdos_dir_read+0x368> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
41c84: e2844020 add r4, r4, #32 <== NOT EXECUTED 41c88: e1540007 cmp r4, r7 <== NOT EXECUTED 41c8c: 2a000066 bcs 41e2c <msdos_dir_read+0x2e4> <== NOT EXECUTED
char* entry = (char*) fs_info->cl_buf + i;
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
41c90: e7dc3004 ldrb r3, [ip, r4] <== NOT EXECUTED 41c94: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
41c98: e08c5004 add r5, ip, r4 <== NOT EXECUTED
/*
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
41c9c: 0a0000ae beq 41f5c <msdos_dir_read+0x414> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
/* Is the directory entry empty */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) == MSDOS_THIS_DIR_ENTRY_EMPTY)
41ca0: e35300e5 cmp r3, #229 ; 0xe5 <== NOT EXECUTED 41ca4: 0afffff6 beq 41c84 <msdos_dir_read+0x13c> <== NOT EXECUTED
continue;
/* Is the directory entry empty a volume label */
if (((*MSDOS_DIR_ATTR(entry)) & MSDOS_ATTR_VOLUME_ID) &&
41ca8: e5d5200b ldrb r2, [r5, #11] <== NOT EXECUTED 41cac: e3120008 tst r2, #8 <== NOT EXECUTED 41cb0: 1afffff0 bne 41c78 <msdos_dir_read+0x130> <== NOT EXECUTED
/*
* Check the attribute to see if the entry is for a long file
* name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
41cb4: e202203f and r2, r2, #63 ; 0x3f <== NOT EXECUTED 41cb8: e352000f cmp r2, #15 <== NOT EXECUTED 41cbc: 0a00007b beq 41eb0 <msdos_dir_read+0x368> <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
41cc0: e3560000 cmp r6, #0 <== NOT EXECUTED
{
lfn_start = FAT_FILE_SHORT_NAME;
start--;
41cc4: 12466001 subne r6, r6, #1 <== NOT EXECUTED 41cc8: 13e09000 mvnne r9, #0 <== NOT EXECUTED
fat_dir_pos_t dir_pos;
/*
* Skip active entries until get the entry to start from.
*/
if (start)
41ccc: 1affffec bne 41c84 <msdos_dir_read+0x13c> <== NOT EXECUTED
* unfortunately there is no method to extract ino except to
* open fat-file descriptor :( ... so, open it
*/
/* get number of cluster we are working with */
rc = fat_file_ioctl(iop->pathinfo.mt_entry, fat_fd, F_CLU_NUM,
41cd0: e59a0028 ldr r0, [sl, #40] ; 0x28 <== NOT EXECUTED 41cd4: e28dcf56 add ip, sp, #344 ; 0x158 <== NOT EXECUTED 41cd8: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 41cdc: e3a02001 mov r2, #1 <== NOT EXECUTED 41ce0: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 41ce4: e58dc000 str ip, [sp] <== NOT EXECUTED 41ce8: ebff8d8d bl 25324 <fat_file_ioctl> <== NOT EXECUTED
j * bts2rd, &cur_cln);
if (rc != RC_OK)
41cec: e3500000 cmp r0, #0 <== NOT EXECUTED 41cf0: 1a0000e2 bne 42080 <msdos_dir_read+0x538> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
41cf4: e59dc158 ldr ip, [sp, #344] ; 0x158 <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
41cf8: e3e03000 mvn r3, #0 <== NOT EXECUTED
dir_pos.sname.ofs = i;
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
41cfc: e59a0028 ldr r0, [sl, #40] ; 0x28 <== NOT EXECUTED 41d00: e28d1f52 add r1, sp, #328 ; 0x148 <== NOT EXECUTED 41d04: e28d2f57 add r2, sp, #348 ; 0x15c <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
41d08: e58d3154 str r3, [sp, #340] ; 0x154 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_dir_pos_init(&dir_pos);
dir_pos.sname.cln = cur_cln;
41d0c: e58dc148 str ip, [sp, #328] ; 0x148 <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
41d10: e58d3150 str r3, [sp, #336] ; 0x150 <== NOT EXECUTED
dir_pos.sname.ofs = i;
41d14: e58d414c str r4, [sp, #332] ; 0x14c <== NOT EXECUTED
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
41d18: ebff8fb8 bl 25c00 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
41d1c: e3500000 cmp r0, #0 <== NOT EXECUTED 41d20: 1a0000f9 bne 4210c <msdos_dir_read+0x5c4> <== NOT EXECUTED
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
tmp_dirent.d_ino = tmp_fat_fd->ino;
41d24: e59d315c ldr r3, [sp, #348] ; 0x15c <== NOT EXECUTED 41d28: e593300c ldr r3, [r3, #12] <== NOT EXECUTED
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
41d2c: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED
tmp_dirent.d_ino = tmp_fat_fd->ino;
41d30: e58d3038 str r3, [sp, #56] ; 0x38 <== NOT EXECUTED
return rc;
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
41d34: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
/*
* If a long file name check if the correct number of
* entries have been found and if the checksum is correct.
* If not return the short file name.
*/
if (lfn_start != FAT_FILE_SHORT_NAME)
41d38: e3790001 cmn r9, #1 <== NOT EXECUTED
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
tmp_dirent.d_reclen = sizeof(struct dirent);
41d3c: e28d2e16 add r2, sp, #352 ; 0x160 <== NOT EXECUTED 41d40: e3a01e11 mov r1, #272 ; 0x110 <== NOT EXECUTED
return rc;
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
41d44: e58d303c str r3, [sp, #60] ; 0x3c <== NOT EXECUTED
tmp_dirent.d_reclen = sizeof(struct dirent);
41d48: e18210bc strh r1, [r2, ip] <== NOT EXECUTED
return rc;
}
/* fill in dirent structure */
/* XXX: from what and in what d_off should be computed ?! */
tmp_dirent.d_off = start + cmpltd;
41d4c: e58d6040 str r6, [sp, #64] ; 0x40 <== NOT EXECUTED
/*
* If a long file name check if the correct number of
* entries have been found and if the checksum is correct.
* If not return the short file name.
*/
if (lfn_start != FAT_FILE_SHORT_NAME)
41d50: 11a02006 movne r2, r6 <== NOT EXECUTED 41d54: 11a03006 movne r3, r6 <== NOT EXECUTED 41d58: 11a00006 movne r0, r6 <== NOT EXECUTED 41d5c: 1a000002 bne 41d6c <msdos_dir_read+0x224> <== NOT EXECUTED 41d60: ea000036 b 41e40 <msdos_dir_read+0x2f8> <== NOT EXECUTED
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
41d64: e2100001 ands r0, r0, #1 <== NOT EXECUTED 41d68: 13a00080 movne r0, #128 ; 0x80 <== NOT EXECUTED 41d6c: e7d51003 ldrb r1, [r5, r3] <== NOT EXECUTED 41d70: e1a02b82 lsl r2, r2, #23 <== NOT EXECUTED 41d74: e0801001 add r1, r0, r1 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
41d78: e2833001 add r3, r3, #1 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
41d7c: e0810c22 add r0, r1, r2, lsr #24 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
41d80: e353000b cmp r3, #11 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
41d84: e20020ff and r2, r0, #255 ; 0xff <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) entry;
int i;
for (i = 0; i < 11; i++, p++)
41d88: 1afffff5 bne 41d64 <msdos_dir_read+0x21c> <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
41d8c: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 41d90: e35b0000 cmp fp, #0 <== NOT EXECUTED 41d94: 01530002 cmpeq r3, r2 <== NOT EXECUTED 41d98: 1a000028 bne 41e40 <msdos_dir_read+0x2f8> <== NOT EXECUTED
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
tmp_dirent.d_name, entry); /* src text */
}
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
41d9c: e59d0034 ldr r0, [sp, #52] ; 0x34 <== NOT EXECUTED 41da0: eb001f8f bl 49be4 <strlen> <== NOT EXECUTED 41da4: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED 41da8: e28d2e16 add r2, sp, #352 ; 0x160 <== NOT EXECUTED 41dac: e18200b1 strh r0, [r2, r1] <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
41db0: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED 41db4: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED 41db8: e28d1038 add r1, sp, #56 ; 0x38 <== NOT EXECUTED 41dbc: e083000c add r0, r3, ip <== NOT EXECUTED 41dc0: e3a02e11 mov r2, #272 ; 0x110 <== NOT EXECUTED 41dc4: eb001139 bl 462b0 <memcpy> <== NOT EXECUTED
iop->offset = iop->offset + sizeof(struct dirent);
41dc8: e28a300c add r3, sl, #12 <== NOT EXECUTED
41dcc: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
41dd0: e3a00e11 mov r0, #272 ; 0x110 <== NOT EXECUTED
41dd4: e0922000 adds r2, r2, r0 <== NOT EXECUTED
41dd8: e3a01000 mov r1, #0 <== NOT EXECUTED
41ddc: e0a33001 adc r3, r3, r1 <== NOT EXECUTED
41de0: e58a200c str r2, [sl, #12] <== NOT EXECUTED
41de4: e58a3010 str r3, [sl, #16] <== NOT EXECUTED
cmpltd += (sizeof(struct dirent));
count -= (sizeof(struct dirent));
/* inode number extracted, close fat-file */
rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
41de8: e59a0028 ldr r0, [sl, #40] ; 0x28 <== NOT EXECUTED 41dec: e59d115c ldr r1, [sp, #348] ; 0x15c <== NOT EXECUTED 41df0: ebff8f58 bl 25b58 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
41df4: e3500000 cmp r0, #0 <== NOT EXECUTED 41df8: 1a0000a0 bne 42080 <msdos_dir_read+0x538> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
41dfc: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
cmpltd += (sizeof(struct dirent));
41e00: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
41e04: e2522e11 subs r2, r2, #272 ; 0x110 <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
cmpltd += (sizeof(struct dirent));
41e08: e2833e11 add r3, r3, #272 ; 0x110 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
41e0c: e58d2018 str r2, [sp, #24] <== NOT EXECUTED
}
memcpy(buffer + cmpltd, &tmp_dirent, sizeof(struct dirent));
iop->offset = iop->offset + sizeof(struct dirent);
cmpltd += (sizeof(struct dirent));
41e10: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
if (count <= 0)
41e14: 0a0000b5 beq 420f0 <msdos_dir_read+0x5a8> <== NOT EXECUTED 41e18: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
rtems_set_errno_and_return_minus_one(EIO);
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
41e1c: e2844020 add r4, r4, #32 <== NOT EXECUTED 41e20: e1540007 cmp r4, r7 <== NOT EXECUTED 41e24: e591c098 ldr ip, [r1, #152] ; 0x98 <== NOT EXECUTED 41e28: 3affff98 bcc 41c90 <msdos_dir_read+0x148> <== NOT EXECUTED 41e2c: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 41e30: e59d3030 ldr r3, [sp, #48] ; 0x30 <== NOT EXECUTED 41e34: e0822003 add r2, r2, r3 <== NOT EXECUTED 41e38: e58d2014 str r2, [sp, #20] <== NOT EXECUTED 41e3c: eaffff76 b 41c1c <msdos_dir_read+0xd4> <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
41e40: e3a03007 mov r3, #7 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
41e44: e7d52003 ldrb r2, [r5, r3] <== NOT EXECUTED 41e48: e3520020 cmp r2, #32 <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
41e4c: e2839001 add r9, r3, #1 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
41e50: 1a000074 bne 42028 <msdos_dir_read+0x4e0> <== NOT EXECUTED
int i;
for (i = 0; i < 11; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entries || (lfn_checksum != cs))
41e54: e1a09003 mov r9, r3 <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
41e58: e2533001 subs r3, r3, #1 <== NOT EXECUTED 41e5c: 2afffff8 bcs 41e44 <msdos_dir_read+0x2fc> <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
41e60: e59d2034 ldr r2, [sp, #52] ; 0x34 <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
}
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
41e64: e5d5300a ldrb r3, [r5, #10] <== NOT EXECUTED 41e68: e3530020 cmp r3, #32 <== NOT EXECUTED 41e6c: 13a00003 movne r0, #3 <== NOT EXECUTED 41e70: 1a00008a bne 420a0 <msdos_dir_read+0x558> <== NOT EXECUTED 41e74: e5d53009 ldrb r3, [r5, #9] <== NOT EXECUTED 41e78: e3530020 cmp r3, #32 <== NOT EXECUTED 41e7c: 13a00002 movne r0, #2 <== NOT EXECUTED
src_tmp = src + MSDOS_SHORT_BASE_LEN+MSDOS_SHORT_EXT_LEN-1);
((i > 0) &&
(*src_tmp == ' '));
i--,src_tmp--)
41e80: e2853009 add r3, r5, #9 <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
}
/*
* find last non-blank character of extension
*/
for ((i = MSDOS_SHORT_EXT_LEN ,
41e84: 1a000085 bne 420a0 <msdos_dir_read+0x558> <== NOT EXECUTED 41e88: e5533001 ldrb r3, [r3, #-1] <== NOT EXECUTED 41e8c: e3530020 cmp r3, #32 <== NOT EXECUTED 41e90: 1a000081 bne 4209c <msdos_dir_read+0x554> <== NOT EXECUTED
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
len++;
}
}
*dst = '\0'; /* terminate string */
41e94: e3a03000 mov r3, #0 <== NOT EXECUTED 41e98: e5c23000 strb r3, [r2] <== NOT EXECUTED
{
/*
* convert dir entry from fixed 8+3 format (without dot)
* to 0..8 + 1dot + 0..3 format
*/
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
41e9c: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED 41ea0: e28d2e16 add r2, sp, #352 ; 0x160 <== NOT EXECUTED 41ea4: e18290b1 strh r9, [r2, r1] <== NOT EXECUTED 41ea8: e3e09000 mvn r9, #0 <== NOT EXECUTED 41eac: eaffffbf b 41db0 <msdos_dir_read+0x268> <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
41eb0: e3790001 cmn r9, #1 <== NOT EXECUTED 41eb4: 0a00000c beq 41eec <msdos_dir_read+0x3a4> <== NOT EXECUTED 41eb8: e1a0c00b mov ip, fp <== NOT EXECUTED 41ebc: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
* If the entry number or the check sum do not match
* forget this series of long directory entries. These could
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
41ec0: e203b03f and fp, r3, #63 ; 0x3f <== NOT EXECUTED 41ec4: e15b000c cmp fp, ip <== NOT EXECUTED
int q;
/*
* Is this is the first entry of a LFN ?
*/
if (lfn_start == FAT_FILE_SHORT_NAME)
41ec8: e58d1020 str r1, [sp, #32] <== NOT EXECUTED
* If the entry number or the check sum do not match
* forget this series of long directory entries. These could
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
41ecc: 0a000018 beq 41f34 <msdos_dir_read+0x3ec> <== NOT EXECUTED 41ed0: e1a0b00c mov fp, ip <== NOT EXECUTED 41ed4: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 41ed8: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 41edc: e3e09000 mvn r9, #0 <== NOT EXECUTED 41ee0: e58dc010 str ip, [sp, #16] <== NOT EXECUTED 41ee4: e591c098 ldr ip, [r1, #152] ; 0x98 <== NOT EXECUTED 41ee8: eaffff65 b 41c84 <msdos_dir_read+0x13c> <== NOT EXECUTED
if (lfn_start == FAT_FILE_SHORT_NAME)
{
/*
* The first entry must have the last long entry flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
41eec: e3130040 tst r3, #64 ; 0x40 <== NOT EXECUTED 41ef0: 0affff63 beq 41c84 <msdos_dir_read+0x13c> <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
41ef4: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED
/*
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
41ef8: e203c03f and ip, r3, #63 ; 0x3f <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
41efc: e5d5300d ldrb r3, [r5, #13] <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
41f00: e0829004 add r9, r2, r4 <== NOT EXECUTED
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
41f04: e59d0034 ldr r0, [sp, #52] ; 0x34 <== NOT EXECUTED 41f08: e3a01000 mov r1, #0 <== NOT EXECUTED 41f0c: e3a02c01 mov r2, #256 ; 0x100 <== NOT EXECUTED
* Get the number of entries so we can count down and
* also the checksum of the short entry.
*/
lfn_entries = (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK);
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
41f10: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
memset (tmp_dirent.d_name, 0, sizeof(tmp_dirent.d_name));
41f14: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 41f18: eb00116b bl 464cc <memset> <== NOT EXECUTED 41f1c: e5d53000 ldrb r3, [r5] <== NOT EXECUTED 41f20: e59dc004 ldr ip, [sp, #4] <== NOT EXECUTED
* If the entry number or the check sum do not match
* forget this series of long directory entries. These could
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
41f24: e203b03f and fp, r3, #63 ; 0x3f <== NOT EXECUTED 41f28: e15b000c cmp fp, ip <== NOT EXECUTED
continue;
/*
* Remember the start location of the long file name.
*/
lfn_start =
41f2c: e1a092a9 lsr r9, r9, #5 <== NOT EXECUTED
* If the entry number or the check sum do not match
* forget this series of long directory entries. These could
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
41f30: 1affffe6 bne 41ed0 <msdos_dir_read+0x388> <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
41f34: e5d5200d ldrb r2, [r5, #13] <== NOT EXECUTED
* If the entry number or the check sum do not match
* forget this series of long directory entries. These could
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
41f38: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 41f3c: e1520003 cmp r2, r3 <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
41f40: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
* If the entry number or the check sum do not match
* forget this series of long directory entries. These could
* be orphaned entries depending on the history of the
* disk.
*/
if ((lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
41f44: 0a00000d beq 41f80 <msdos_dir_read+0x438> <== NOT EXECUTED 41f48: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 41f4c: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 41f50: e3e09000 mvn r9, #0 <== NOT EXECUTED 41f54: e591c098 ldr ip, [r1, #152] ; 0x98 <== NOT EXECUTED 41f58: eaffff49 b 41c84 <msdos_dir_read+0x13c> <== NOT EXECUTED
* Is this directory from here on empty ?
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
{
rtems_semaphore_release(fs_info->vol_sema);
41f5c: e28d3008 add r3, sp, #8 <== NOT EXECUTED
41f60: e8931008 ldm r3, {r3, ip} <== NOT EXECUTED
41f64: e59c0094 ldr r0, [ip, #148] ; 0x94 <== NOT EXECUTED
41f68: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
41f6c: ebff299c bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return cmpltd;
41f70: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
return cmpltd;
}
41f74: e1a00003 mov r0, r3 <== NOT EXECUTED
41f78: e28dde16 add sp, sp, #352 ; 0x160 <== NOT EXECUTED
41f7c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* The DOS maximum length is 255 characters without the
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
41f80: e24cb001 sub fp, ip, #1 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
41f84: e08b308b add r3, fp, fp, lsl #1 <== NOT EXECUTED 41f88: e08b3103 add r3, fp, r3, lsl #2 <== NOT EXECUTED 41f8c: e28d2038 add r2, sp, #56 ; 0x38 <== NOT EXECUTED 41f90: e2831010 add r1, r3, #16 <== NOT EXECUTED 41f94: e0821001 add r1, r2, r1 <== NOT EXECUTED
* trailing nul character. We need to range check the length to
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
41f98: e2855001 add r5, r5, #1 <== NOT EXECUTED
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
41f9c: e3a02001 mov r2, #1 <== NOT EXECUTED 41fa0: ea000006 b 41fc0 <msdos_dir_read+0x478> <== NOT EXECUTED
tmp_dirent.d_name[o++] = *p;
if (*p == '\0')
break;
switch (q)
41fa4: e350000a cmp r0, #10 <== NOT EXECUTED 41fa8: 0a000011 beq 41ff4 <msdos_dir_read+0x4ac> <== NOT EXECUTED
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
41fac: e352000c cmp r2, #12 <== NOT EXECUTED 41fb0: ca00002f bgt 42074 <msdos_dir_read+0x52c> <== NOT EXECUTED
break;
case 10:
p += 4;
break;
default:
p += 2;
41fb4: e2855002 add r5, r5, #2 <== NOT EXECUTED
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
41fb8: e2822001 add r2, r2, #1 <== NOT EXECUTED 41fbc: e2811001 add r1, r1, #1 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
41fc0: e35300fe cmp r3, #254 ; 0xfe <== NOT EXECUTED
* fit in the directory entry name field.
*/
lfn_entries--;
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
41fc4: e2420001 sub r0, r2, #1 <== NOT EXECUTED
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
break;
tmp_dirent.d_name[o++] = *p;
41fc8: e2833001 add r3, r3, #1 <== NOT EXECUTED
p = entry + 1;
o = lfn_entries * MSDOS_LFN_LEN_PER_ENTRY;
for (q = 0; q < MSDOS_LFN_LEN_PER_ENTRY; q++)
{
if (o >= (sizeof(tmp_dirent.d_name) - 1))
41fcc: 8a000055 bhi 42128 <msdos_dir_read+0x5e0> <== NOT EXECUTED
break;
tmp_dirent.d_name[o++] = *p;
41fd0: e5d5c000 ldrb ip, [r5] <== NOT EXECUTED 41fd4: e5c1c000 strb ip, [r1] <== NOT EXECUTED
if (*p == '\0')
41fd8: e5d5c000 ldrb ip, [r5] <== NOT EXECUTED 41fdc: e35c0000 cmp ip, #0 <== NOT EXECUTED 41fe0: 0affff8c beq 41e18 <msdos_dir_read+0x2d0> <== NOT EXECUTED
break;
switch (q)
41fe4: e3500004 cmp r0, #4 <== NOT EXECUTED 41fe8: 1affffed bne 41fa4 <msdos_dir_read+0x45c> <== NOT EXECUTED
{
case 4:
p += 5;
41fec: e2855005 add r5, r5, #5 <== NOT EXECUTED
break;
41ff0: eafffff0 b 41fb8 <msdos_dir_read+0x470> <== NOT EXECUTED
case 10:
p += 4;
41ff4: e2855004 add r5, r5, #4 <== NOT EXECUTED
break;
41ff8: eaffffee b 41fb8 <msdos_dir_read+0x470> <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
41ffc: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 42000: e59c3024 ldr r3, [ip, #36] ; 0x24 <== NOT EXECUTED 42004: e3530000 cmp r3, #0 <== NOT EXECUTED 42008: 1afffedd bne 41b84 <msdos_dir_read+0x3c> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16))) ?
4200c: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 42010: e5d1300a ldrb r3, [r1, #10] <== NOT EXECUTED 42014: e3130003 tst r3, #3 <== NOT EXECUTED 42018: 0afffed9 beq 41b84 <msdos_dir_read+0x3c> <== NOT EXECUTED
* optimization: we know that root directory for FAT12/16 volumes is
* sequential set of sectors and any cluster is sequential set of sectors
* too, so read such set of sectors is quick operation for low-level IO
* layer.
*/
bts2rd = (FAT_FD_OF_ROOT_DIR(fat_fd) &&
4201c: e59c2018 ldr r2, [ip, #24] <== NOT EXECUTED 42020: e58d2030 str r2, [sp, #48] ; 0x30 <== NOT EXECUTED 42024: eafffed9 b 41b90 <msdos_dir_read+0x48> <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
42028: e3590000 cmp r9, #0 <== NOT EXECUTED 4202c: daffff8b ble 41e60 <msdos_dir_read+0x318> <== NOT EXECUTED
const char *src_tmp;
/*
* find last non-blank character of base name
*/
for ((i = MSDOS_SHORT_BASE_LEN ,
42030: e28dc038 add ip, sp, #56 ; 0x38 <== NOT EXECUTED 42034: e28c1011 add r1, ip, #17 <== NOT EXECUTED
* RETURNS: * the number of bytes read on success, or -1 if error occured (errno * set apropriately). */ ssize_t msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
42038: e3a03000 mov r3, #0 <== NOT EXECUTED
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
4203c: e7d52003 ldrb r2, [r5, r3] <== NOT EXECUTED 42040: e5980000 ldr r0, [r8] <== NOT EXECUTED 42044: e0800002 add r0, r0, r2 <== NOT EXECUTED 42048: e5d00001 ldrb r0, [r0, #1] <== NOT EXECUTED 4204c: e2000003 and r0, r0, #3 <== NOT EXECUTED 42050: e3500001 cmp r0, #1 <== NOT EXECUTED 42054: e2833001 add r3, r3, #1 <== NOT EXECUTED 42058: 02822020 addeq r2, r2, #32 <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
4205c: e1530009 cmp r3, r9 <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
42060: e5412001 strb r2, [r1, #-1] <== NOT EXECUTED 42064: e1a02001 mov r2, r1 <== NOT EXECUTED 42068: e2811001 add r1, r1, #1 <== NOT EXECUTED
/*
* copy base name to destination
*/
src_tmp = src;
len = i;
while (i-- > 0) {
4206c: 1afffff2 bne 4203c <msdos_dir_read+0x4f4> <== NOT EXECUTED 42070: eaffff7b b 41e64 <msdos_dir_read+0x31c> <== NOT EXECUTED 42074: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 42078: e592c098 ldr ip, [r2, #152] ; 0x98 <== NOT EXECUTED 4207c: eaffff00 b 41c84 <msdos_dir_read+0x13c> <== NOT EXECUTED
/* inode number extracted, close fat-file */
rc = fat_file_close(iop->pathinfo.mt_entry, tmp_fat_fd);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
42080: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 42084: e1a03000 mov r3, r0 <== NOT EXECUTED 42088: e5910094 ldr r0, [r1, #148] ; 0x94 <== NOT EXECUTED 4208c: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 42090: ebff2953 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
42094: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 42098: eaffffb5 b 41f74 <msdos_dir_read+0x42c> <== NOT EXECUTED
tmp_dirent.d_namlen = msdos_format_dirent_with_dot(
tmp_dirent.d_name, entry); /* src text */
}
else
{
tmp_dirent.d_namlen = strlen(tmp_dirent.d_name);
4209c: e3a00001 mov r0, #1 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
420a0: e1a0e002 mov lr, r2 <== NOT EXECUTED 420a4: e3a0302e mov r3, #46 ; 0x2e <== NOT EXECUTED
len += i + 1; /* extension + dot */
420a8: e2899001 add r9, r9, #1 <== NOT EXECUTED
{};
/*
* extension is not empty
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
420ac: e4ce3001 strb r3, [lr], #1 <== NOT EXECUTED
len += i + 1; /* extension + dot */
420b0: e0899000 add r9, r9, r0 <== NOT EXECUTED
* RETURNS: * the number of bytes read on success, or -1 if error occured (errno * set apropriately). */ ssize_t msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
420b4: e085c000 add ip, r5, r0 <== NOT EXECUTED
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
*dst++ = tolower((unsigned char)(*src_tmp++));
420b8: e5d53008 ldrb r3, [r5, #8] <== NOT EXECUTED 420bc: e5981000 ldr r1, [r8] <== NOT EXECUTED 420c0: e0811003 add r1, r1, r3 <== NOT EXECUTED 420c4: e5d11001 ldrb r1, [r1, #1] <== NOT EXECUTED 420c8: e2011003 and r1, r1, #3 <== NOT EXECUTED 420cc: e3510001 cmp r1, #1 <== NOT EXECUTED 420d0: e2855001 add r5, r5, #1 <== NOT EXECUTED 420d4: 02833020 addeq r3, r3, #32 <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
420d8: e155000c cmp r5, ip <== NOT EXECUTED
*dst++ = tolower((unsigned char)(*src_tmp++));
420dc: e5e23001 strb r3, [r2, #1]! <== NOT EXECUTED
*/
if (i > 0) {
*dst++ = '.'; /* append dot */
len += i + 1; /* extension + dot */
src_tmp = src + MSDOS_SHORT_BASE_LEN;
while (i-- > 0) {
420e0: 1afffff4 bne 420b8 <msdos_dir_read+0x570> <== NOT EXECUTED 420e4: e0899000 add r9, r9, r0 <== NOT EXECUTED 420e8: e08e2000 add r2, lr, r0 <== NOT EXECUTED 420ec: eaffff68 b 41e94 <msdos_dir_read+0x34c> <== NOT EXECUTED
* RETURNS: * the number of bytes read on success, or -1 if error occured (errno * set apropriately). */ ssize_t msdos_dir_read(rtems_libio_t *iop, void *buffer, size_t count)
420f0: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
break;
}
j++;
}
rtems_semaphore_release(fs_info->vol_sema);
420f4: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 420f8: e59c0094 ldr r0, [ip, #148] ; 0x94 <== NOT EXECUTED 420fc: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 42100: ebff2937 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 42104: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
return cmpltd;
42108: eaffff99 b 41f74 <msdos_dir_read+0x42c> <== NOT EXECUTED
dir_pos.sname.cln = cur_cln;
dir_pos.sname.ofs = i;
rc = fat_file_open(iop->pathinfo.mt_entry, &dir_pos, &tmp_fat_fd);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
4210c: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 42110: e1a03000 mov r3, r0 <== NOT EXECUTED 42114: e5920094 ldr r0, [r2, #148] ; 0x94 <== NOT EXECUTED 42118: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 4211c: ebff2930 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
42120: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 42124: eaffff92 b 41f74 <msdos_dir_read+0x42c> <== NOT EXECUTED 42128: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 4212c: e593c098 ldr ip, [r3, #152] ; 0x98 <== NOT EXECUTED 42130: eafffed3 b 41c84 <msdos_dir_read+0x13c> <== NOT EXECUTED
*/
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, (j * bts2rd),
bts2rd, fs_info->cl_buf);
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
rtems_semaphore_release(fs_info->vol_sema);
42134: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 42138: e5930094 ldr r0, [r3, #148] ; 0x94 <== NOT EXECUTED 4213c: ebff2928 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
42140: eb0003aa bl 42ff0 <__errno> <== NOT EXECUTED 42144: e3a03005 mov r3, #5 <== NOT EXECUTED 42148: e5803000 str r3, [r0] <== NOT EXECUTED 4214c: e3e03000 mvn r3, #0 <== NOT EXECUTED 42150: eaffff87 b 41f74 <msdos_dir_read+0x42c> <== NOT EXECUTED
}
for (i = 0; i < ret; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
42154: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 42158: eaffffe5 b 420f4 <msdos_dir_read+0x5ac> <== NOT EXECUTED
000419f0 <msdos_dir_rmnod>:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
419f0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
419f4: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED 419f8: e5936034 ldr r6, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd = pathloc->node_access;
bool is_empty = false;
419fc: e3a03000 mov r3, #0 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
41a00: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 41a04: e1a04001 mov r4, r1 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
bool is_empty = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
41a08: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 41a0c: e1a01003 mov r1, r3 <== NOT EXECUTED 41a10: e1a02003 mov r2, r3 <== NOT EXECUTED
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
bool is_empty = false;
41a14: e5cd3003 strb r3, [sp, #3] <== NOT EXECUTED
rtems_filesystem_location_info_t *pathloc)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
41a18: e5945000 ldr r5, [r4] <== NOT EXECUTED
bool is_empty = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
41a1c: ebff2aa8 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
41a20: e3500000 cmp r0, #0 <== NOT EXECUTED 41a24: 1a000023 bne 41ab8 <msdos_dir_rmnod+0xc8> <== NOT EXECUTED
/*
* We deny attempts to delete open directory (if directory is current
* directory we assume it is open one)
*/
if (fat_fd->links_num > 1)
41a28: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 41a2c: e3530001 cmp r3, #1 <== NOT EXECUTED 41a30: 8a000019 bhi 41a9c <msdos_dir_rmnod+0xac> <== NOT EXECUTED
}
/*
* You cannot remove a node that still has children
*/
rc = msdos_dir_is_empty(pathloc->mt_entry, fat_fd, &is_empty);
41a34: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 41a38: e1a01005 mov r1, r5 <== NOT EXECUTED 41a3c: e28d2003 add r2, sp, #3 <== NOT EXECUTED 41a40: ebffd7db bl 379b4 <msdos_dir_is_empty> <== NOT EXECUTED
if (rc != RC_OK)
41a44: e2507000 subs r7, r0, #0 <== NOT EXECUTED 41a48: 1a00000e bne 41a88 <msdos_dir_rmnod+0x98> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (!is_empty)
41a4c: e5dd3003 ldrb r3, [sp, #3] <== NOT EXECUTED 41a50: e3530000 cmp r3, #0 <== NOT EXECUTED 41a54: 0a00001c beq 41acc <msdos_dir_rmnod+0xdc> <== NOT EXECUTED
}
/*
* You cannot remove the file system root node.
*/
if (pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access)
41a58: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 41a5c: e5943000 ldr r3, [r4] <== NOT EXECUTED 41a60: e590201c ldr r2, [r0, #28] <== NOT EXECUTED 41a64: e1520003 cmp r2, r3 <== NOT EXECUTED 41a68: 0a00000b beq 41a9c <msdos_dir_rmnod+0xac> <== NOT EXECUTED
* You cannot remove a mountpoint.
* not used - mount() not implemenetd yet.
*/
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry, &fat_fd->dir_pos,
41a6c: e2851020 add r1, r5, #32 <== NOT EXECUTED 41a70: e3a020e5 mov r2, #229 ; 0xe5 <== NOT EXECUTED 41a74: ebffd871 bl 37c40 <msdos_set_first_char4file_name> <== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
41a78: e2507000 subs r7, r0, #0 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_file_mark_removed(pathloc->mt_entry, fat_fd);
41a7c: 05940010 ldreq r0, [r4, #16] <== NOT EXECUTED 41a80: 01a01005 moveq r1, r5 <== NOT EXECUTED 41a84: 0bff8e12 bleq 252d4 <fat_file_mark_removed> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
41a88: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 41a8c: ebff2ad4 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
41a90: e1a00007 mov r0, r7 <== NOT EXECUTED
41a94: e28dd004 add sp, sp, #4 <== NOT EXECUTED
41a98: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
/*
* You cannot remove the file system root node.
*/
if (pathloc->mt_entry->mt_fs_root.node_access == pathloc->node_access)
{
rtems_semaphore_release(fs_info->vol_sema);
41a9c: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 41aa0: ebff2acf bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EBUSY);
41aa4: eb000551 bl 42ff0 <__errno> <== NOT EXECUTED 41aa8: e3a03010 mov r3, #16 <== NOT EXECUTED 41aac: e5803000 str r3, [r0] <== NOT EXECUTED 41ab0: e3e07000 mvn r7, #0 <== NOT EXECUTED 41ab4: eafffff5 b 41a90 <msdos_dir_rmnod+0xa0> <== NOT EXECUTED
bool is_empty = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
41ab8: eb00054c bl 42ff0 <__errno> <== NOT EXECUTED 41abc: e3a03005 mov r3, #5 <== NOT EXECUTED 41ac0: e5803000 str r3, [r0] <== NOT EXECUTED 41ac4: e3e07000 mvn r7, #0 <== NOT EXECUTED 41ac8: eafffff0 b 41a90 <msdos_dir_rmnod+0xa0> <== NOT EXECUTED
return rc;
}
if (!is_empty)
{
rtems_semaphore_release(fs_info->vol_sema);
41acc: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 41ad0: ebff2ac3 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOTEMPTY);
41ad4: eb000545 bl 42ff0 <__errno> <== NOT EXECUTED 41ad8: e3a0305a mov r3, #90 ; 0x5a <== NOT EXECUTED 41adc: e5803000 str r3, [r0] <== NOT EXECUTED 41ae0: e3e07000 mvn r7, #0 <== NOT EXECUTED 41ae4: eaffffe9 b 41a90 <msdos_dir_rmnod+0xa0> <== NOT EXECUTED
00041948 <msdos_dir_stat>:
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
41948: e5902010 ldr r2, [r0, #16] <== NOT EXECUTED
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
4194c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
41950: e5925034 ldr r5, [r2, #52] ; 0x34 <== NOT EXECUTED
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
41954: e1a04001 mov r4, r1 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
41958: e3a01000 mov r1, #0 <== NOT EXECUTED
int
msdos_dir_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
4195c: e1a03000 mov r3, r0 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
41960: e1a02001 mov r2, r1 <== NOT EXECUTED 41964: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
struct stat *buf
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
41968: e5936000 ldr r6, [r3] <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
4196c: ebff2ad4 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
41970: e2507000 subs r7, r0, #0 <== NOT EXECUTED 41974: 1a000018 bne 419dc <msdos_dir_stat+0x94> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
41978: e596200c ldr r2, [r6, #12] <== NOT EXECUTED
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
4197c: e3a03c41 mov r3, #16640 ; 0x4100 <== NOT EXECUTED 41980: e28330ff add r3, r3, #255 ; 0xff <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
41984: e5842008 str r2, [r4, #8] <== NOT EXECUTED
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
41988: e584300c str r3, [r4, #12] <== NOT EXECUTED
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
4198c: e5963018 ldr r3, [r6, #24] <== NOT EXECUTED
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
41990: e1d520b0 ldrh r2, [r5] <== NOT EXECUTED
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
41994: e1a014a3 lsr r1, r3, #9 <== NOT EXECUTED 41998: e5841044 str r1, [r4, #68] ; 0x44 <== NOT EXECUTED
buf->st_blksize = fs_info->fat.vol.bps;
4199c: e5842040 str r2, [r4, #64] ; 0x40 <== NOT EXECUTED
buf->st_mtime = fat_fd->mtime;
419a0: e5962040 ldr r2, [r6, #64] ; 0x40 <== NOT EXECUTED 419a4: e5842030 str r2, [r4, #48] ; 0x30 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
419a8: e2852054 add r2, r5, #84 ; 0x54 <== NOT EXECUTED
419ac: e8920006 ldm r2, {r1, r2} <== NOT EXECUTED
419b0: e8840006 stm r4, {r1, r2} <== NOT EXECUTED
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFDIR | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
419b4: e3a01000 mov r1, #0 <== NOT EXECUTED 419b8: e3a02000 mov r2, #0 <== NOT EXECUTED 419bc: e5841018 str r1, [r4, #24] <== NOT EXECUTED 419c0: e584201c str r2, [r4, #28] <== NOT EXECUTED
buf->st_size = fat_fd->fat_file_size;
419c4: e5843020 str r3, [r4, #32] <== NOT EXECUTED 419c8: e5847024 str r7, [r4, #36] ; 0x24 <== NOT EXECUTED
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
buf->st_mtime = fat_fd->mtime;
rtems_semaphore_release(fs_info->vol_sema);
419cc: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED 419d0: ebff2b03 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 419d4: e1a00007 mov r0, r7 <== NOT EXECUTED
return RC_OK;
}
419d8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
419dc: eb000583 bl 42ff0 <__errno> <== NOT EXECUTED
419e0: e3a03005 mov r3, #5 <== NOT EXECUTED
419e4: e5803000 str r3, [r0] <== NOT EXECUTED
419e8: e3e00000 mvn r0, #0 <== NOT EXECUTED
419ec: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00041ae8 <msdos_dir_sync>:
msdos_dir_sync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->file_info;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
41ae8: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_sync(rtems_libio_t *iop)
{
41aec: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->file_info;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
41af0: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
41af4: e3a01000 mov r1, #0 <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*/
int
msdos_dir_sync(rtems_libio_t *iop)
{
41af8: e1a04000 mov r4, r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->file_info;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
41afc: e1a02001 mov r2, r1 <== NOT EXECUTED 41b00: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
int
msdos_dir_sync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->file_info;
41b04: e5946038 ldr r6, [r4, #56] ; 0x38 <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
41b08: ebff2a6d bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
41b0c: e3500000 cmp r0, #0 <== NOT EXECUTED 41b10: 1a000007 bne 41b34 <msdos_dir_sync+0x4c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
41b14: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 41b18: e1a01006 mov r1, r6 <== NOT EXECUTED 41b1c: ebff8da4 bl 251b4 <fat_file_datasync> <== NOT EXECUTED 41b20: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
41b24: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED 41b28: ebff2aad bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
41b2c: e1a00004 mov r0, r4 <== NOT EXECUTED
41b30: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
41b34: eb00052d bl 42ff0 <__errno> <== NOT EXECUTED 41b38: e3a03005 mov r3, #5 <== NOT EXECUTED 41b3c: e5803000 str r3, [r0] <== NOT EXECUTED 41b40: e3e04000 mvn r4, #0 <== NOT EXECUTED 41b44: eafffff8 b 41b2c <msdos_dir_sync+0x44> <== NOT EXECUTED
000364d4 <msdos_eval4make>:
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
364d4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
364d8: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED 364dc: e5937034 ldr r7, [r3, #52] ; 0x34 <== NOT EXECUTED
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
364e0: e24dd020 sub sp, sp, #32 <== NOT EXECUTED 364e4: e1a04001 mov r4, r1 <== NOT EXECUTED
int i = 0;
int token_len;
const char *token;
bool done = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
364e8: e3a01000 mov r1, #0 <== NOT EXECUTED
msdos_eval4make(
const char *path,
rtems_filesystem_location_info_t *pathloc,
const char **name
)
{
364ec: e58d2000 str r2, [sp] <== NOT EXECUTED 364f0: e1a08000 mov r8, r0 <== NOT EXECUTED
int i = 0;
int token_len;
const char *token;
bool done = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
364f4: e1a02001 mov r2, r1 <== NOT EXECUTED 364f8: e5970094 ldr r0, [r7, #148] ; 0x94 <== NOT EXECUTED 364fc: ebff57f0 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
36500: e3500000 cmp r0, #0 <== NOT EXECUTED 36504: 1a000092 bne 36754 <msdos_eval4make+0x280> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
if (!pathloc->node_access)
36508: e5940000 ldr r0, [r4] <== NOT EXECUTED 3650c: e3500000 cmp r0, #0 <== NOT EXECUTED 36510: 0a000069 beq 366bc <msdos_eval4make+0x1e8> <== NOT EXECUTED
goto err;
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
36514: ebffbabf bl 25018 <fat_file_reopen> <== NOT EXECUTED
if (rc != RC_OK)
36518: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3651c: 11a0b005 movne fp, r5 <== NOT EXECUTED 36520: 1a00001d bne 3659c <msdos_eval4make+0xc8> <== NOT EXECUTED 36524: e1a06005 mov r6, r5 <== NOT EXECUTED 36528: e28d9018 add r9, sp, #24 <== NOT EXECUTED 3652c: e28db01c add fp, sp, #28 <== NOT EXECUTED
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
36530: e088a006 add sl, r8, r6 <== NOT EXECUTED 36534: e1a0000a mov r0, sl <== NOT EXECUTED 36538: eb004da9 bl 49be4 <strlen> <== NOT EXECUTED 3653c: e1a02009 mov r2, r9 <== NOT EXECUTED 36540: e1a01000 mov r1, r0 <== NOT EXECUTED 36544: e1a0300b mov r3, fp <== NOT EXECUTED 36548: e1a0000a mov r0, sl <== NOT EXECUTED 3654c: eb000661 bl 37ed8 <msdos_get_token> <== NOT EXECUTED
i += token_len;
fat_fd = pathloc->node_access;
36550: e594c000 ldr ip, [r4] <== NOT EXECUTED
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
i += token_len;
36554: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED
fat_fd = pathloc->node_access;
36558: e1a0a00c mov sl, ip <== NOT EXECUTED
goto err;
while (!done)
{
type = msdos_get_token(&path[i], strlen(&path[i]), &token, &token_len);
i += token_len;
3655c: e0866002 add r6, r6, r2 <== NOT EXECUTED
fat_fd = pathloc->node_access;
switch (type)
36560: e3500004 cmp r0, #4 <== NOT EXECUTED 36564: 979ff100 ldrls pc, [pc, r0, lsl #2] <== NOT EXECUTED 36568: eafffff0 b 36530 <msdos_eval4make+0x5c> <== NOT EXECUTED 3656c: 000366a8 .word 0x000366a8 <== NOT EXECUTED 36570: 00036530 .word 0x00036530 <== NOT EXECUTED 36574: 00036660 .word 0x00036660 <== NOT EXECUTED 36578: 000365b4 .word 0x000365b4 <== NOT EXECUTED 3657c: 00036580 .word 0x00036580 <== NOT EXECUTED
case MSDOS_CURRENT_DIR:
break;
case MSDOS_INVALID_TOKEN:
errno = ENAMETOOLONG;
36580: eb00329a bl 42ff0 <__errno> <== NOT EXECUTED 36584: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED 36588: e5803000 str r3, [r0] <== NOT EXECUTED 3658c: e3e0b000 mvn fp, #0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
error:
fat_file_close(pathloc->mt_entry, fat_fd);
36590: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 36594: e1a0100a mov r1, sl <== NOT EXECUTED 36598: ebffbd6e bl 25b58 <fat_file_close> <== NOT EXECUTED
err:
rtems_semaphore_release(fs_info->vol_sema);
3659c: e5970094 ldr r0, [r7, #148] ; 0x94 <== NOT EXECUTED 365a0: ebff580f bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 365a4: e1a0500b mov r5, fp <== NOT EXECUTED
return rc;
}
365a8: e1a00005 mov r0, r5 <== NOT EXECUTED
365ac: e28dd020 add sp, sp, #32 <== NOT EXECUTED
365b0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
365b4: e59c3010 ldr r3, [ip, #16] <== NOT EXECUTED 365b8: e3530001 cmp r3, #1 <== NOT EXECUTED
/*
* Otherwise find the token name in the present location and
* set the node access to the point we have found.
*/
rc = msdos_find_name(pathloc, token, token_len);
365bc: e1a00004 mov r0, r4 <== NOT EXECUTED
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
365c0: 1a000068 bne 36768 <msdos_eval4make+0x294> <== NOT EXECUTED
/*
* Otherwise find the token name in the present location and
* set the node access to the point we have found.
*/
rc = msdos_find_name(pathloc, token, token_len);
365c4: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED 365c8: eb0007ba bl 384b8 <msdos_find_name> <== NOT EXECUTED
if (rc)
365cc: e3500000 cmp r0, #0 <== NOT EXECUTED 365d0: 0affffd6 beq 36530 <msdos_eval4make+0x5c> <== NOT EXECUTED
{
if (rc != MSDOS_NAME_NOT_FOUND_ERR)
365d4: e3a03c7d mov r3, #32000 ; 0x7d00 <== NOT EXECUTED 365d8: e2833001 add r3, r3, #1 <== NOT EXECUTED 365dc: e1500003 cmp r0, r3 <== NOT EXECUTED 365e0: 1a000019 bne 3664c <msdos_eval4make+0x178> <== NOT EXECUTED
break;
}
}
*name = &path[i - token_len];
365e4: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 365e8: e59d2000 ldr r2, [sp] <== NOT EXECUTED 365ec: e0633006 rsb r3, r3, r6 <== NOT EXECUTED 365f0: e0883003 add r3, r8, r3 <== NOT EXECUTED 365f4: e5823000 str r3, [r2] <== NOT EXECUTED
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++)
365f8: e7d80006 ldrb r0, [r8, r6] <== NOT EXECUTED 365fc: e3500000 cmp r0, #0 <== NOT EXECUTED 36600: e0886006 add r6, r8, r6 <== NOT EXECUTED 36604: 1a00000d bne 36640 <msdos_eval4make+0x16c> <== NOT EXECUTED
rc = -1;
goto error;
}
}
fat_fd = pathloc->node_access;
36608: e594a000 ldr sl, [r4] <== NOT EXECUTED
if (fat_fd->fat_file_type != FAT_DIRECTORY)
3660c: e59a3010 ldr r3, [sl, #16] <== NOT EXECUTED 36610: e3530001 cmp r3, #1 <== NOT EXECUTED 36614: 1a000053 bne 36768 <msdos_eval4make+0x294> <== NOT EXECUTED
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
loc->handlers = fs_info->directory_handlers;
36618: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED 3661c: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED 36620: e593308c ldr r3, [r3, #140] ; 0x8c <== NOT EXECUTED
goto error;
}
msdos_set_handlers(pathloc);
rtems_semaphore_release(fs_info->vol_sema);
36624: e5970094 ldr r0, [r7, #148] ; 0x94 <== NOT EXECUTED
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
loc->handlers = fs_info->directory_handlers;
36628: e5843008 str r3, [r4, #8] <== NOT EXECUTED
goto error;
}
msdos_set_handlers(pathloc);
rtems_semaphore_release(fs_info->vol_sema);
3662c: ebff57ec bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
36630: eaffffdc b 365a8 <msdos_eval4make+0xd4> <== NOT EXECUTED
/*
* We have evaluated the path as far as we can.
* Verify there is not any invalid stuff at the end of the name.
*/
for( ; path[i] != '\0'; i++)
36634: e5f60001 ldrb r0, [r6, #1]! <== NOT EXECUTED 36638: e3500000 cmp r0, #0 <== NOT EXECUTED 3663c: 0afffff1 beq 36608 <msdos_eval4make+0x134> <== NOT EXECUTED
{
if (!msdos_is_separator(path[i]))
36640: ebff4c54 bl 9798 <rtems_filesystem_is_separator> <== NOT EXECUTED 36644: e3500000 cmp r0, #0 <== NOT EXECUTED 36648: 1afffff9 bne 36634 <msdos_eval4make+0x160> <== NOT EXECUTED
{
errno = ENOENT;
3664c: eb003267 bl 42ff0 <__errno> <== NOT EXECUTED 36650: e3a03002 mov r3, #2 <== NOT EXECUTED 36654: e5803000 str r3, [r0] <== NOT EXECUTED 36658: e3e0b000 mvn fp, #0 <== NOT EXECUTED
rc = -1;
goto error;
3665c: eaffffcb b 36590 <msdos_eval4make+0xbc> <== NOT EXECUTED
{
case MSDOS_UP_DIR:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
36660: e59c3010 ldr r3, [ip, #16] <== NOT EXECUTED 36664: e3530001 cmp r3, #1 <== NOT EXECUTED
pathloc, name);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
36668: e1a00004 mov r0, r4 <== NOT EXECUTED
{
case MSDOS_UP_DIR:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
3666c: 1a00003d bne 36768 <msdos_eval4make+0x294> <== NOT EXECUTED
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access)
36670: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED
}
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
36674: e591301c ldr r3, [r1, #28] <== NOT EXECUTED 36678: e15c0003 cmp ip, r3 <== NOT EXECUTED 3667c: 0a000013 beq 366d0 <msdos_eval4make+0x1fc> <== NOT EXECUTED
pathloc, name);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
36680: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED 36684: eb00078b bl 384b8 <msdos_find_name> <== NOT EXECUTED
if (rc != RC_OK)
36688: e3500000 cmp r0, #0 <== NOT EXECUTED 3668c: 0affffa7 beq 36530 <msdos_eval4make+0x5c> <== NOT EXECUTED
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
36690: e3a03c7d mov r3, #32000 ; 0x7d00 <== NOT EXECUTED 36694: e2833001 add r3, r3, #1 <== NOT EXECUTED 36698: e1500003 cmp r0, r3 <== NOT EXECUTED 3669c: e1a0b000 mov fp, r0 <== NOT EXECUTED 366a0: 1affffba bne 36590 <msdos_eval4make+0xbc> <== NOT EXECUTED 366a4: eaffffe8 b 3664c <msdos_eval4make+0x178> <== NOT EXECUTED
done = true;
}
break;
case MSDOS_NO_MORE_PATH:
errno = EEXIST;
366a8: eb003250 bl 42ff0 <__errno> <== NOT EXECUTED 366ac: e3a03011 mov r3, #17 <== NOT EXECUTED 366b0: e5803000 str r3, [r0] <== NOT EXECUTED 366b4: e3e0b000 mvn fp, #0 <== NOT EXECUTED
rc = -1;
goto error;
366b8: eaffffb4 b 36590 <msdos_eval4make+0xbc> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
if (!pathloc->node_access)
{
errno = ENOENT;
366bc: eb00324b bl 42ff0 <__errno> <== NOT EXECUTED 366c0: e3a03002 mov r3, #2 <== NOT EXECUTED 366c4: e5803000 str r3, [r0] <== NOT EXECUTED 366c8: e3e0b000 mvn fp, #0 <== NOT EXECUTED
rc = -1;
goto err;
366cc: eaffffb2 b 3659c <msdos_eval4make+0xc8> <== NOT EXECUTED
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
rtems_filesystem_root.node_access)
366d0: e59f20a4 ldr r2, [pc, #164] ; 3677c <msdos_eval4make+0x2a8><== NOT EXECUTED 366d4: e5923000 ldr r3, [r2] <== NOT EXECUTED 366d8: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED 366dc: e15c0003 cmp ip, r3 <== NOT EXECUTED 366e0: 0affff92 beq 36530 <msdos_eval4make+0x5c> <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
366e4: e281a008 add sl, r1, #8 <== NOT EXECUTED
366e8: e8ba000f ldm sl!, {r0, r1, r2, r3} <== NOT EXECUTED
366ec: e28d5004 add r5, sp, #4 <== NOT EXECUTED
366f0: e8a5000f stmia r5!, {r0, r1, r2, r3} <== NOT EXECUTED
*pathloc = newloc;
366f4: e28de004 add lr, sp, #4 <== NOT EXECUTED
366f8: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
366fc: e59ae000 ldr lr, [sl] <== NOT EXECUTED
*pathloc = newloc;
36700: e1a0a004 mov sl, r4 <== NOT EXECUTED
36704: e8aa000f stmia sl!, {r0, r1, r2, r3} <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, fat_fd);
36708: e1a0000e mov r0, lr <== NOT EXECUTED
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
*pathloc = newloc;
3670c: e58ae000 str lr, [sl] <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, fat_fd);
36710: e1a0100c mov r1, ip <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
36714: e585e000 str lr, [r5] <== NOT EXECUTED
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
36718: ebffbd0e bl 25b58 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
3671c: e250b000 subs fp, r0, #0 <== NOT EXECUTED 36720: 1affff9d bne 3659c <msdos_eval4make+0xc8> <== NOT EXECUTED
goto err;
rtems_semaphore_release(fs_info->vol_sema);
36724: e5970094 ldr r0, [r7, #148] ; 0x94 <== NOT EXECUTED 36728: ebff57ad bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(&path[i-token_len],
3672c: e59d001c ldr r0, [sp, #28] <== NOT EXECUTED 36730: e0600006 rsb r0, r0, r6 <== NOT EXECUTED 36734: e0880000 add r0, r8, r0 <== NOT EXECUTED 36738: e1a01004 mov r1, r4 <== NOT EXECUTED 3673c: e59d2000 ldr r2, [sp] <== NOT EXECUTED 36740: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 36744: e1a0e00f mov lr, pc <== NOT EXECUTED 36748: e593f004 ldr pc, [r3, #4] <== NOT EXECUTED 3674c: e1a05000 mov r5, r0 <== NOT EXECUTED 36750: eaffff94 b 365a8 <msdos_eval4make+0xd4> <== NOT EXECUTED
bool done = false;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
36754: eb003225 bl 42ff0 <__errno> <== NOT EXECUTED 36758: e3a03005 mov r3, #5 <== NOT EXECUTED 3675c: e5803000 str r3, [r0] <== NOT EXECUTED 36760: e3e05000 mvn r5, #0 <== NOT EXECUTED 36764: eaffff8f b 365a8 <msdos_eval4make+0xd4> <== NOT EXECUTED
fat_fd = pathloc->node_access;
if (fat_fd->fat_file_type != FAT_DIRECTORY)
{
errno = ENOTDIR;
36768: eb003220 bl 42ff0 <__errno> <== NOT EXECUTED 3676c: e3a03014 mov r3, #20 <== NOT EXECUTED 36770: e5803000 str r3, [r0] <== NOT EXECUTED 36774: e3e0b000 mvn fp, #0 <== NOT EXECUTED
rc = -1;
goto error;
36778: eaffff84 b 36590 <msdos_eval4make+0xbc> <== NOT EXECUTED
0003625c <msdos_eval_path>:
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
3625c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
36260: e1a04003 mov r4, r3 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
36264: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED 36268: e5939034 ldr r9, [r3, #52] ; 0x34 <== NOT EXECUTED
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
3626c: e24dd024 sub sp, sp, #36 ; 0x24 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
rtems_filesystem_location_info_t newloc;
int i = 0;
int token_len = 0;
36270: e3a03000 mov r3, #0 <== NOT EXECUTED
const char *pathname,
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc
)
{
36274: e88d0005 stm sp, {r0, r2} <== NOT EXECUTED
36278: e1a05001 mov r5, r1 <== NOT EXECUTED
int i = 0;
int token_len = 0;
msdos_token_types_t type = MSDOS_CURRENT_DIR;
const char *token;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
3627c: e5990094 ldr r0, [r9, #148] ; 0x94 <== NOT EXECUTED 36280: e1a01003 mov r1, r3 <== NOT EXECUTED 36284: e1a02003 mov r2, r3 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
rtems_filesystem_location_info_t newloc;
int i = 0;
int token_len = 0;
36288: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
msdos_token_types_t type = MSDOS_CURRENT_DIR;
const char *token;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
3628c: ebff588c bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
36290: e3500000 cmp r0, #0 <== NOT EXECUTED 36294: 1a000083 bne 364a8 <msdos_eval_path+0x24c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
if (!pathloc->node_access)
36298: e5940000 ldr r0, [r4] <== NOT EXECUTED 3629c: e3500000 cmp r0, #0 <== NOT EXECUTED 362a0: 0a000058 beq 36408 <msdos_eval_path+0x1ac> <== NOT EXECUTED
goto err;
}
fat_fd = pathloc->node_access;
rc = fat_file_reopen(fat_fd);
362a4: ebffbb5b bl 25018 <fat_file_reopen> <== NOT EXECUTED
if (rc != RC_OK)
362a8: e2508000 subs r8, r0, #0 <== NOT EXECUTED 362ac: 11a0b008 movne fp, r8 <== NOT EXECUTED 362b0: 1a000027 bne 36354 <msdos_eval_path+0xf8> <== NOT EXECUTED 362b4: e1a06008 mov r6, r8 <== NOT EXECUTED 362b8: e28db020 add fp, sp, #32 <== NOT EXECUTED
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
362bc: e59dc000 ldr ip, [sp] <== NOT EXECUTED 362c0: e1a01005 mov r1, r5 <== NOT EXECUTED 362c4: e28d201c add r2, sp, #28 <== NOT EXECUTED 362c8: e08c0006 add r0, ip, r6 <== NOT EXECUTED 362cc: e1a0300b mov r3, fp <== NOT EXECUTED 362d0: eb000700 bl 37ed8 <msdos_get_token> <== NOT EXECUTED
pathnamelen -= token_len;
362d4: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED
i += token_len;
fat_fd = pathloc->node_access;
switch (type)
362d8: e3500003 cmp r0, #3 <== NOT EXECUTED
if (rc != RC_OK)
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
{
type = msdos_get_token(&pathname[i], pathnamelen, &token, &token_len);
362dc: e1a0a000 mov sl, r0 <== NOT EXECUTED
pathnamelen -= token_len;
362e0: e0625005 rsb r5, r2, r5 <== NOT EXECUTED
i += token_len;
362e4: e0866002 add r6, r6, r2 <== NOT EXECUTED
fat_fd = pathloc->node_access;
362e8: e5947000 ldr r7, [r4] <== NOT EXECUTED
switch (type)
362ec: 0a00001e beq 3636c <msdos_eval_path+0x110> <== NOT EXECUTED 362f0: e3500004 cmp r0, #4 <== NOT EXECUTED 362f4: 0a00000f beq 36338 <msdos_eval_path+0xdc> <== NOT EXECUTED 362f8: e3500002 cmp r0, #2 <== NOT EXECUTED 362fc: 0a00002c beq 363b4 <msdos_eval_path+0x158> <== NOT EXECUTED
rc = fat_file_reopen(fat_fd);
if (rc != RC_OK)
goto err;
while ((type != MSDOS_NO_MORE_PATH) && (type != MSDOS_INVALID_TOKEN))
36300: e3500000 cmp r0, #0 <== NOT EXECUTED 36304: 13500004 cmpne r0, #4 <== NOT EXECUTED 36308: 1affffeb bne 362bc <msdos_eval_path+0x60> <== NOT EXECUTED
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
3630c: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
36310: e5972010 ldr r2, [r7, #16] <== NOT EXECUTED
* None
*/
static void
msdos_set_handlers(rtems_filesystem_location_info_t *loc)
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
36314: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
36318: e3520001 cmp r2, #1 <== NOT EXECUTED
loc->handlers = fs_info->directory_handlers;
3631c: 0593308c ldreq r3, [r3, #140] ; 0x8c <== NOT EXECUTED
else
loc->handlers = fs_info->file_handlers;
36320: 15933090 ldrne r3, [r3, #144] ; 0x90 <== NOT EXECUTED
{
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
if (fat_fd->fat_file_type == FAT_DIRECTORY)
loc->handlers = fs_info->directory_handlers;
36324: 05843008 streq r3, [r4, #8] <== NOT EXECUTED
else
loc->handlers = fs_info->file_handlers;
36328: 15843008 strne r3, [r4, #8] <== NOT EXECUTED
*/
fat_fd = pathloc->node_access;
msdos_set_handlers(pathloc);
rtems_semaphore_release(fs_info->vol_sema);
3632c: e5990094 ldr r0, [r9, #148] ; 0x94 <== NOT EXECUTED 36330: ebff58ab bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
36334: ea000009 b 36360 <msdos_eval_path+0x104> <== NOT EXECUTED
case MSDOS_NO_MORE_PATH:
case MSDOS_CURRENT_DIR:
break;
case MSDOS_INVALID_TOKEN:
errno = ENAMETOOLONG;
36338: eb00332c bl 42ff0 <__errno> <== NOT EXECUTED 3633c: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED 36340: e5803000 str r3, [r0] <== NOT EXECUTED 36344: e3e0b000 mvn fp, #0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
error:
fat_file_close(pathloc->mt_entry, fat_fd);
36348: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 3634c: e1a01007 mov r1, r7 <== NOT EXECUTED 36350: ebffbe00 bl 25b58 <fat_file_close> <== NOT EXECUTED
err:
rtems_semaphore_release(fs_info->vol_sema);
36354: e5990094 ldr r0, [r9, #148] ; 0x94 <== NOT EXECUTED 36358: ebff58a1 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 3635c: e1a0800b mov r8, fp <== NOT EXECUTED
return rc;
}
36360: e1a00008 mov r0, r8 <== NOT EXECUTED
36364: e28dd024 add sp, sp, #36 ; 0x24 <== NOT EXECUTED
36368: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
3636c: e5973010 ldr r3, [r7, #16] <== NOT EXECUTED 36370: e3530001 cmp r3, #1 <== NOT EXECUTED
/*
* Otherwise find the token name in the present location and
* set the node access to the point we have found.
*/
rc = msdos_find_name(pathloc, token, token_len);
36374: e1a00004 mov r0, r4 <== NOT EXECUTED
case MSDOS_NAME:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
36378: 1a00004f bne 364bc <msdos_eval_path+0x260> <== NOT EXECUTED
/*
* Otherwise find the token name in the present location and
* set the node access to the point we have found.
*/
rc = msdos_find_name(pathloc, token, token_len);
3637c: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 36380: eb00084c bl 384b8 <msdos_find_name> <== NOT EXECUTED
if (rc != RC_OK)
36384: e3500000 cmp r0, #0 <== NOT EXECUTED 36388: 0affffcb beq 362bc <msdos_eval_path+0x60> <== NOT EXECUTED
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
3638c: e3a03c7d mov r3, #32000 ; 0x7d00 <== NOT EXECUTED 36390: e2833001 add r3, r3, #1 <== NOT EXECUTED 36394: e1500003 cmp r0, r3 <== NOT EXECUTED 36398: e1a0b000 mov fp, r0 <== NOT EXECUTED 3639c: 1affffe9 bne 36348 <msdos_eval_path+0xec> <== NOT EXECUTED
{
errno = ENOENT;
363a0: eb003312 bl 42ff0 <__errno> <== NOT EXECUTED 363a4: e3a03002 mov r3, #2 <== NOT EXECUTED 363a8: e5803000 str r3, [r0] <== NOT EXECUTED 363ac: e3e0b000 mvn fp, #0 <== NOT EXECUTED 363b0: eaffffe4 b 36348 <msdos_eval_path+0xec> <== NOT EXECUTED
{
case MSDOS_UP_DIR:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
363b4: e5973010 ldr r3, [r7, #16] <== NOT EXECUTED 363b8: e3530001 cmp r3, #1 <== NOT EXECUTED
flags, pathloc);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
363bc: e1a00004 mov r0, r4 <== NOT EXECUTED
{
case MSDOS_UP_DIR:
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
363c0: 1a00003d bne 364bc <msdos_eval_path+0x260> <== NOT EXECUTED
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
pathloc->mt_entry->mt_fs_root.node_access)
363c4: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED
}
/*
* Am I at the root of this mounted filesystem?
*/
if (pathloc->node_access ==
363c8: e591301c ldr r3, [r1, #28] <== NOT EXECUTED 363cc: e1570003 cmp r7, r3 <== NOT EXECUTED 363d0: 0a000011 beq 3641c <msdos_eval_path+0x1c0> <== NOT EXECUTED
flags, pathloc);
}
}
else
{
rc = msdos_find_name(pathloc, token, token_len);
363d4: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 363d8: eb000836 bl 384b8 <msdos_find_name> <== NOT EXECUTED
if (rc != RC_OK)
363dc: e3500000 cmp r0, #0 <== NOT EXECUTED 363e0: 0affffb5 beq 362bc <msdos_eval_path+0x60> <== NOT EXECUTED
{
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
363e4: e3a03c7d mov r3, #32000 ; 0x7d00 <== NOT EXECUTED 363e8: e2833001 add r3, r3, #1 <== NOT EXECUTED 363ec: e1500003 cmp r0, r3 <== NOT EXECUTED 363f0: e1a0b000 mov fp, r0 <== NOT EXECUTED 363f4: 1affffd3 bne 36348 <msdos_eval_path+0xec> <== NOT EXECUTED
{
errno = ENOENT;
363f8: eb0032fc bl 42ff0 <__errno> <== NOT EXECUTED 363fc: e3e0b000 mvn fp, #0 <== NOT EXECUTED 36400: e580a000 str sl, [r0] <== NOT EXECUTED 36404: eaffffcf b 36348 <msdos_eval_path+0xec> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
if (!pathloc->node_access)
{
errno = ENOENT;
36408: eb0032f8 bl 42ff0 <__errno> <== NOT EXECUTED 3640c: e3a03002 mov r3, #2 <== NOT EXECUTED 36410: e5803000 str r3, [r0] <== NOT EXECUTED 36414: e3e0b000 mvn fp, #0 <== NOT EXECUTED
rc = -1;
goto err;
36418: eaffffcd b 36354 <msdos_eval_path+0xf8> <== NOT EXECUTED
/*
* Am I at the root of all filesystems?
* XXX: MSDOS is not supposed to be base fs.
*/
if (pathloc->node_access ==
rtems_filesystem_root.node_access)
3641c: e59f20ac ldr r2, [pc, #172] ; 364d0 <msdos_eval_path+0x274><== NOT EXECUTED 36420: e5923000 ldr r3, [r2] <== NOT EXECUTED 36424: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED 36428: e1570003 cmp r7, r3 <== NOT EXECUTED 3642c: 0affffa2 beq 362bc <msdos_eval_path+0x60> <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
36430: e2818008 add r8, r1, #8 <== NOT EXECUTED
36434: e8b8000f ldm r8!, {r0, r1, r2, r3} <== NOT EXECUTED
36438: e28de008 add lr, sp, #8 <== NOT EXECUTED
3643c: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
*pathloc = newloc;
36440: e28dc008 add ip, sp, #8 <== NOT EXECUTED
36444: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
36448: e598c000 ldr ip, [r8] <== NOT EXECUTED
*pathloc = newloc;
3644c: e1a08004 mov r8, r4 <== NOT EXECUTED
36450: e8a8000f stmia r8!, {r0, r1, r2, r3} <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, fat_fd);
36454: e1a0000c mov r0, ip <== NOT EXECUTED
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
*pathloc = newloc;
36458: e588c000 str ip, [r8] <== NOT EXECUTED
rc = fat_file_close(pathloc->mt_entry, fat_fd);
3645c: e1a01007 mov r1, r7 <== NOT EXECUTED
{
break; /* Throw out the .. in this case */
}
else
{
newloc = pathloc->mt_entry->mt_point_node;
36460: e58ec000 str ip, [lr] <== NOT EXECUTED
*pathloc = newloc;
rc = fat_file_close(pathloc->mt_entry, fat_fd);
36464: ebffbdbb bl 25b58 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
36468: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3646c: 1affffb8 bne 36354 <msdos_eval_path+0xf8> <== NOT EXECUTED
goto err;
rtems_semaphore_release(fs_info->vol_sema);
36470: e5990094 ldr r0, [r9, #148] ; 0x94 <== NOT EXECUTED 36474: ebff585a bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)(&(pathname[i-token_len]),
36478: e59d1020 ldr r1, [sp, #32] <== NOT EXECUTED 3647c: e59dc000 ldr ip, [sp] <== NOT EXECUTED 36480: e0610006 rsb r0, r1, r6 <== NOT EXECUTED 36484: e08c0000 add r0, ip, r0 <== NOT EXECUTED 36488: e0851001 add r1, r5, r1 <== NOT EXECUTED 3648c: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 36490: e1a03004 mov r3, r4 <== NOT EXECUTED 36494: e594c00c ldr ip, [r4, #12] <== NOT EXECUTED 36498: e1a0e00f mov lr, pc <== NOT EXECUTED 3649c: e59cf000 ldr pc, [ip] <== NOT EXECUTED 364a0: e1a08000 mov r8, r0 <== NOT EXECUTED 364a4: eaffffad b 36360 <msdos_eval_path+0x104> <== NOT EXECUTED
const char *token;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
364a8: eb0032d0 bl 42ff0 <__errno> <== NOT EXECUTED 364ac: e3a03005 mov r3, #5 <== NOT EXECUTED 364b0: e5803000 str r3, [r0] <== NOT EXECUTED 364b4: e3e08000 mvn r8, #0 <== NOT EXECUTED 364b8: eaffffa8 b 36360 <msdos_eval_path+0x104> <== NOT EXECUTED
/*
* Only a directory can be decended into.
*/
if (fat_fd->fat_file_type != FAT_DIRECTORY)
{
errno = ENOTSUP;
364bc: eb0032cb bl 42ff0 <__errno> <== NOT EXECUTED 364c0: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 364c4: e5803000 str r3, [r0] <== NOT EXECUTED 364c8: e3e0b000 mvn fp, #0 <== NOT EXECUTED
rc = -1;
goto error;
364cc: eaffff9d b 36348 <msdos_eval_path+0xec> <== NOT EXECUTED
00036788 <msdos_file_chmod>:
int
msdos_file_chmod(rtems_filesystem_location_info_t *pathloc,
mode_t mode)
{
return RC_OK;
}
36788: e3a00000 mov r0, #0 <== NOT EXECUTED 3678c: e12fff1e bx lr <== NOT EXECUTED
00036c8c <msdos_file_close>:
int
msdos_file_close(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
36c8c: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
* RC_OK, if file closed successfully, or -1 if error occured (errno set
* appropriately)
*/
int
msdos_file_close(rtems_libio_t *iop)
{
36c90: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
36c94: e5936034 ldr r6, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36c98: e3a01000 mov r1, #0 <== NOT EXECUTED
* RC_OK, if file closed successfully, or -1 if error occured (errno set
* appropriately)
*/
int
msdos_file_close(rtems_libio_t *iop)
{
36c9c: e1a04000 mov r4, r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36ca0: e1a02001 mov r2, r1 <== NOT EXECUTED 36ca4: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED
msdos_file_close(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
36ca8: e5945038 ldr r5, [r4, #56] ; 0x38 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36cac: ebff5604 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
36cb0: e3500000 cmp r0, #0 <== NOT EXECUTED 36cb4: 1a00001a bne 36d24 <msdos_file_close+0x98> <== NOT EXECUTED
/*
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
36cb8: e5d53030 ldrb r3, [r5, #48] ; 0x30 <== NOT EXECUTED 36cbc: e3130001 tst r3, #1 <== NOT EXECUTED 36cc0: 0a000007 beq 36ce4 <msdos_file_close+0x58> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
rc = fat_file_close(iop->pathinfo.mt_entry, fat_fd);
36cc4: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 36cc8: e1a01005 mov r1, r5 <== NOT EXECUTED 36ccc: ebffbba1 bl 25b58 <fat_file_close> <== NOT EXECUTED 36cd0: e1a07000 mov r7, r0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
36cd4: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 36cd8: ebff5641 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
36cdc: e1a00007 mov r0, r7 <== NOT EXECUTED
36ce0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
* if fat-file descriptor is not marked as "removed", synchronize
* size, first cluster number, write time and date fields of the file
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
36ce4: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 36ce8: e1a01005 mov r1, r5 <== NOT EXECUTED 36cec: eb0003a4 bl 37b84 <msdos_set_first_cluster_num> <== NOT EXECUTED
if (rc != RC_OK)
36cf0: e2507000 subs r7, r0, #0 <== NOT EXECUTED 36cf4: 1afffff6 bne 36cd4 <msdos_file_close+0x48> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
36cf8: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 36cfc: e1a01005 mov r1, r5 <== NOT EXECUTED 36d00: eb00037f bl 37b04 <msdos_set_file_size> <== NOT EXECUTED
if (rc != RC_OK)
36d04: e2507000 subs r7, r0, #0 <== NOT EXECUTED 36d08: 1afffff1 bne 36cd4 <msdos_file_close+0x48> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
36d0c: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 36d10: e1a01005 mov r1, r5 <== NOT EXECUTED 36d14: eb000425 bl 37db0 <msdos_set_dir_wrt_time_and_date> <== NOT EXECUTED
if (rc != RC_OK)
36d18: e2507000 subs r7, r0, #0 <== NOT EXECUTED 36d1c: 0affffe8 beq 36cc4 <msdos_file_close+0x38> <== NOT EXECUTED 36d20: eaffffeb b 36cd4 <msdos_file_close+0x48> <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
36d24: eb0030b1 bl 42ff0 <__errno> <== NOT EXECUTED 36d28: e3a03005 mov r3, #5 <== NOT EXECUTED 36d2c: e5803000 str r3, [r0] <== NOT EXECUTED 36d30: e3e07000 mvn r7, #0 <== NOT EXECUTED 36d34: eaffffe8 b 36cdc <msdos_file_close+0x50> <== NOT EXECUTED
000368a8 <msdos_file_datasync>:
msdos_file_datasync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->file_info;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
368a8: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_datasync(rtems_libio_t *iop)
{
368ac: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->file_info;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
368b0: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
368b4: e3a01000 mov r1, #0 <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_datasync(rtems_libio_t *iop)
{
368b8: e1a04000 mov r4, r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->file_info;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
368bc: e1a02001 mov r2, r1 <== NOT EXECUTED 368c0: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
int
msdos_file_datasync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->file_info;
368c4: e5946038 ldr r6, [r4, #56] ; 0x38 <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
368c8: ebff56fd bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
368cc: e2507000 subs r7, r0, #0 <== NOT EXECUTED 368d0: 1a000006 bne 368f0 <msdos_file_datasync+0x48> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
368d4: e1a01006 mov r1, r6 <== NOT EXECUTED 368d8: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 368dc: ebffba34 bl 251b4 <fat_file_datasync> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
368e0: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED 368e4: ebff573e bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 368e8: e1a00007 mov r0, r7 <== NOT EXECUTED
return RC_OK;
}
368ec: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
368f0: eb0031be bl 42ff0 <__errno> <== NOT EXECUTED
368f4: e3a03005 mov r3, #5 <== NOT EXECUTED
368f8: e5803000 str r3, [r0] <== NOT EXECUTED
368fc: e3e00000 mvn r0, #0 <== NOT EXECUTED
36900: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
000369c4 <msdos_file_ftruncate>:
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)
{
369c4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
369c8: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)
{
369cc: e1a06002 mov r6, r2 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
369d0: e5905038 ldr r5, [r0, #56] ; 0x38 <== NOT EXECUTED
if (length >= fat_fd->fat_file_size)
369d4: e3a02000 mov r2, #0 <== NOT EXECUTED 369d8: e1520006 cmp r2, r6 <== NOT EXECUTED
int
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
369dc: e5938034 ldr r8, [r3, #52] ; 0x34 <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately).
*/
int
msdos_file_ftruncate(rtems_libio_t *iop, rtems_off64_t length)
{
369e0: e1a04000 mov r4, r0 <== NOT EXECUTED 369e4: e1a07001 mov r7, r1 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
if (length >= fat_fd->fat_file_size)
369e8: e5953018 ldr r3, [r5, #24] <== NOT EXECUTED 369ec: ca000005 bgt 36a08 <msdos_file_ftruncate+0x44> <== NOT EXECUTED 369f0: 0a000002 beq 36a00 <msdos_file_ftruncate+0x3c> <== NOT EXECUTED 369f4: e3a0a000 mov sl, #0 <== NOT EXECUTED
if (length < fat_fd->fat_file_size)
iop->size = fat_fd->fat_file_size = length;
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
}
369f8: e1a0000a mov r0, sl <== NOT EXECUTED
369fc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
if (length >= fat_fd->fat_file_size)
36a00: e1530001 cmp r3, r1 <== NOT EXECUTED 36a04: 9afffffa bls 369f4 <msdos_file_ftruncate+0x30> <== NOT EXECUTED
return RC_OK;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36a08: e3a01000 mov r1, #0 <== NOT EXECUTED 36a0c: e5980094 ldr r0, [r8, #148] ; 0x94 <== NOT EXECUTED 36a10: e1a02001 mov r2, r1 <== NOT EXECUTED 36a14: ebff56aa bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
36a18: e3500000 cmp r0, #0 <== NOT EXECUTED 36a1c: 1a000013 bne 36a70 <msdos_file_ftruncate+0xac> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_truncate(iop->pathinfo.mt_entry, fat_fd, length);
36a20: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 36a24: e1a01005 mov r1, r5 <== NOT EXECUTED 36a28: e1a02007 mov r2, r7 <== NOT EXECUTED 36a2c: ebffba76 bl 2540c <fat_file_truncate> <== NOT EXECUTED
if (rc != RC_OK)
36a30: e250a000 subs sl, r0, #0 <== NOT EXECUTED 36a34: 1a000009 bne 36a60 <msdos_file_ftruncate+0x9c> <== NOT EXECUTED
/*
* fat_file_truncate do nothing if new length >= fat-file size, so update
* file size only if length < fat-file size
*/
if (length < fat_fd->fat_file_size)
36a38: e15a0006 cmp sl, r6 <== NOT EXECUTED 36a3c: e5953018 ldr r3, [r5, #24] <== NOT EXECUTED 36a40: ca000002 bgt 36a50 <msdos_file_ftruncate+0x8c> <== NOT EXECUTED 36a44: 1a000005 bne 36a60 <msdos_file_ftruncate+0x9c> <== NOT EXECUTED 36a48: e1530007 cmp r3, r7 <== NOT EXECUTED 36a4c: 9a000003 bls 36a60 <msdos_file_ftruncate+0x9c> <== NOT EXECUTED
iop->size = fat_fd->fat_file_size = length;
36a50: e3a03000 mov r3, #0 <== NOT EXECUTED 36a54: e5843008 str r3, [r4, #8] <== NOT EXECUTED 36a58: e5857018 str r7, [r5, #24] <== NOT EXECUTED 36a5c: e5847004 str r7, [r4, #4] <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
36a60: e5980094 ldr r0, [r8, #148] ; 0x94 <== NOT EXECUTED 36a64: ebff56de bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
}
36a68: e1a0000a mov r0, sl <== NOT EXECUTED
36a6c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return RC_OK;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
36a70: eb00315e bl 42ff0 <__errno> <== NOT EXECUTED 36a74: e3a03005 mov r3, #5 <== NOT EXECUTED 36a78: e5803000 str r3, [r0] <== NOT EXECUTED 36a7c: e3e0a000 mvn sl, #0 <== NOT EXECUTED 36a80: eaffffdc b 369f8 <msdos_file_ftruncate+0x34> <== NOT EXECUTED
00036780 <msdos_file_ioctl>:
msdos_file_ioctl(rtems_libio_t *iop,uint32_t command, void *buffer)
{
int rc = RC_OK;
return rc;
}
36780: e3a00000 mov r0, #0 <== NOT EXECUTED 36784: e12fff1e bx lr <== NOT EXECUTED
00036a84 <msdos_file_lseek>:
* new offset on success, or -1 if error occured (errno set
* appropriately).
*/
rtems_off64_t
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
36a84: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
36a88: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 36a8c: e5936034 ldr r6, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->file_info;
uint32_t real_size = 0;
36a90: e3a03000 mov r3, #0 <== NOT EXECUTED
* new offset on success, or -1 if error occured (errno set
* appropriately).
*/
rtems_off64_t
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
36a94: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 36a98: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
uint32_t real_size = 0;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36a9c: e1a01003 mov r1, r3 <== NOT EXECUTED 36aa0: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 36aa4: e1a02003 mov r2, r3 <== NOT EXECUTED
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
uint32_t real_size = 0;
36aa8: e58d3000 str r3, [sp] <== NOT EXECUTED
msdos_file_lseek(rtems_libio_t *iop, rtems_off64_t offset, int whence)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
36aac: e5945038 ldr r5, [r4, #56] ; 0x38 <== NOT EXECUTED
uint32_t real_size = 0;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36ab0: ebff5683 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
36ab4: e3500000 cmp r0, #0 <== NOT EXECUTED 36ab8: 1a00001b bne 36b2c <msdos_file_lseek+0xa8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset,
36abc: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 36ac0: e1a01005 mov r1, r5 <== NOT EXECUTED 36ac4: e594200c ldr r2, [r4, #12] <== NOT EXECUTED 36ac8: e1a0300d mov r3, sp <== NOT EXECUTED 36acc: ebffba90 bl 25514 <fat_file_extend> <== NOT EXECUTED
&real_size);
if (rc != RC_OK)
36ad0: e2507000 subs r7, r0, #0 <== NOT EXECUTED 36ad4: 1a00000f bne 36b18 <msdos_file_lseek+0x94> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (real_size > fat_fd->fat_file_size)
36ad8: e5952018 ldr r2, [r5, #24] <== NOT EXECUTED 36adc: e59d3000 ldr r3, [sp] <== NOT EXECUTED 36ae0: e1520003 cmp r2, r3 <== NOT EXECUTED
fat_fd->fat_file_size = iop->offset = real_size;
36ae4: 31a02003 movcc r2, r3 <== NOT EXECUTED 36ae8: 35852018 strcc r2, [r5, #24] <== NOT EXECUTED 36aec: 3584200c strcc r2, [r4, #12] <== NOT EXECUTED 36af0: 35847010 strcc r7, [r4, #16] <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
36af4: e9840084 stmib r4, {r2, r7} <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
36af8: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 36afc: ebff56b8 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return iop->offset;
36b00: e284400c add r4, r4, #12 <== NOT EXECUTED
36b04: e8940018 ldm r4, {r3, r4} <== NOT EXECUTED
}
36b08: e1a01004 mov r1, r4 <== NOT EXECUTED
36b0c: e1a00003 mov r0, r3 <== NOT EXECUTED
36b10: e28dd004 add sp, sp, #4 <== NOT EXECUTED
36b14: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
rc = fat_file_extend(iop->pathinfo.mt_entry, fat_fd, iop->offset,
&real_size);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
36b18: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 36b1c: ebff56b0 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
36b20: e1a03007 mov r3, r7 <== NOT EXECUTED 36b24: e1a04fc3 asr r4, r3, #31 <== NOT EXECUTED 36b28: eafffff6 b 36b08 <msdos_file_lseek+0x84> <== NOT EXECUTED
uint32_t real_size = 0;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
36b2c: eb00312f bl 42ff0 <__errno> <== NOT EXECUTED 36b30: e3a03005 mov r3, #5 <== NOT EXECUTED 36b34: e5803000 str r3, [r0] <== NOT EXECUTED 36b38: e3e04000 mvn r4, #0 <== NOT EXECUTED 36b3c: e3e03000 mvn r3, #0 <== NOT EXECUTED 36b40: eafffff0 b 36b08 <msdos_file_lseek+0x84> <== NOT EXECUTED
00036d38 <msdos_file_open>:
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
36d38: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
* and errno set appropriately
*/
int
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
36d3c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
36d40: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36d44: e3a01000 mov r1, #0 <== NOT EXECUTED
* and errno set appropriately
*/
int
msdos_file_open(rtems_libio_t *iop, const char *pathname, uint32_t flag,
uint32_t mode)
{
36d48: e1a04000 mov r4, r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36d4c: e1a02001 mov r2, r1 <== NOT EXECUTED 36d50: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
uint32_t mode)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
36d54: e5946038 ldr r6, [r4, #56] ; 0x38 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36d58: ebff55d9 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
36d5c: e3500000 cmp r0, #0 <== NOT EXECUTED 36d60: 1a000011 bne 36dac <msdos_file_open+0x74> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_reopen(fat_fd);
36d64: e1a00006 mov r0, r6 <== NOT EXECUTED 36d68: ebffb8aa bl 25018 <fat_file_reopen> <== NOT EXECUTED
if (rc != RC_OK)
36d6c: e2507000 subs r7, r0, #0 <== NOT EXECUTED 36d70: 1a000009 bne 36d9c <msdos_file_open+0x64> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
36d74: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 36d78: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
iop->offset = fat_fd->fat_file_size;
36d7c: 15963018 ldrne r3, [r6, #24] <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
if (iop->flags & LIBIO_FLAGS_APPEND)
36d80: 05963018 ldreq r3, [r6, #24] <== NOT EXECUTED 36d84: 01a02007 moveq r2, r7 <== NOT EXECUTED
iop->offset = fat_fd->fat_file_size;
36d88: 11a02007 movne r2, r7 <== NOT EXECUTED 36d8c: 15847010 strne r7, [r4, #16] <== NOT EXECUTED 36d90: 1584300c strne r3, [r4, #12] <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
36d94: e5842008 str r2, [r4, #8] <== NOT EXECUTED 36d98: e5843004 str r3, [r4, #4] <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
36d9c: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED 36da0: ebff560f bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
}
36da4: e1a00007 mov r0, r7 <== NOT EXECUTED
36da8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
36dac: eb00308f bl 42ff0 <__errno> <== NOT EXECUTED 36db0: e3a03005 mov r3, #5 <== NOT EXECUTED 36db4: e5803000 str r3, [r0] <== NOT EXECUTED 36db8: e3e07000 mvn r7, #0 <== NOT EXECUTED 36dbc: eafffff8 b 36da4 <msdos_file_open+0x6c> <== NOT EXECUTED
00036c10 <msdos_file_read>:
* the number of bytes read on success, or -1 if error occured (errno set
* appropriately)
*/
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
36c10: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
36c14: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 36c18: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
* the number of bytes read on success, or -1 if error occured (errno set
* appropriately)
*/
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
36c1c: e1a05001 mov r5, r1 <== NOT EXECUTED
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36c20: e3a01000 mov r1, #0 <== NOT EXECUTED
* the number of bytes read on success, or -1 if error occured (errno set
* appropriately)
*/
ssize_t
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
36c24: e1a06000 mov r6, r0 <== NOT EXECUTED 36c28: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 36c2c: e1a07002 mov r7, r2 <== NOT EXECUTED
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36c30: e5940094 ldr r0, [r4, #148] ; 0x94 <== NOT EXECUTED 36c34: e1a02001 mov r2, r1 <== NOT EXECUTED
msdos_file_read(rtems_libio_t *iop, void *buffer, size_t count)
{
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
36c38: e5968038 ldr r8, [r6, #56] ; 0x38 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36c3c: ebff5620 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
36c40: e3500000 cmp r0, #0 <== NOT EXECUTED 36c44: 1a00000b bne 36c78 <msdos_file_read+0x68> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
ret = fat_file_read(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
36c48: e596200c ldr r2, [r6, #12] <== NOT EXECUTED 36c4c: e5960028 ldr r0, [r6, #40] ; 0x28 <== NOT EXECUTED 36c50: e1a01008 mov r1, r8 <== NOT EXECUTED 36c54: e1a03007 mov r3, r7 <== NOT EXECUTED 36c58: e58d5000 str r5, [sp] <== NOT EXECUTED 36c5c: ebffbb3a bl 2594c <fat_file_read> <== NOT EXECUTED 36c60: e1a05000 mov r5, r0 <== NOT EXECUTED
buffer);
rtems_semaphore_release(fs_info->vol_sema);
36c64: e5940094 ldr r0, [r4, #148] ; 0x94 <== NOT EXECUTED 36c68: ebff565d bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return ret;
}
36c6c: e1a00005 mov r0, r5 <== NOT EXECUTED
36c70: e28dd004 add sp, sp, #4 <== NOT EXECUTED
36c74: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
36c78: eb0030dc bl 42ff0 <__errno> <== NOT EXECUTED 36c7c: e3a03005 mov r3, #5 <== NOT EXECUTED 36c80: e5803000 str r3, [r0] <== NOT EXECUTED 36c84: e3e05000 mvn r5, #0 <== NOT EXECUTED 36c88: eafffff7 b 36c6c <msdos_file_read+0x5c> <== NOT EXECUTED
00036838 <msdos_file_rmnod>:
msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
36838: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
3683c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
36840: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_rmnod(rtems_filesystem_location_info_t *parent_pathloc,
rtems_filesystem_location_info_t *pathloc)
{
36844: e1a04001 mov r4, r1 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36848: e3a01000 mov r1, #0 <== NOT EXECUTED 3684c: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED 36850: e1a02001 mov r2, r1 <== NOT EXECUTED
rtems_filesystem_location_info_t *pathloc)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = pathloc->node_access;
36854: e5946000 ldr r6, [r4] <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36858: ebff5719 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
3685c: e3500000 cmp r0, #0 <== NOT EXECUTED 36860: 1a00000b bne 36894 <msdos_file_rmnod+0x5c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
/* mark file removed */
rc = msdos_set_first_char4file_name(pathloc->mt_entry,
36864: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 36868: e2861020 add r1, r6, #32 <== NOT EXECUTED 3686c: e3a020e5 mov r2, #229 ; 0xe5 <== NOT EXECUTED 36870: eb0004f2 bl 37c40 <msdos_set_first_char4file_name> <== NOT EXECUTED
&fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
if (rc != RC_OK)
36874: e2507000 subs r7, r0, #0 <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
fat_file_mark_removed(pathloc->mt_entry, fat_fd);
36878: 05940010 ldreq r0, [r4, #16] <== NOT EXECUTED 3687c: 01a01006 moveq r1, r6 <== NOT EXECUTED 36880: 0bffba93 bleq 252d4 <fat_file_mark_removed> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
36884: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED 36888: ebff5755 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return RC_OK;
}
3688c: e1a00007 mov r0, r7 <== NOT EXECUTED
36890: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
fat_file_fd_t *fat_fd = pathloc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
36894: eb0031d5 bl 42ff0 <__errno> <== NOT EXECUTED 36898: e3a03005 mov r3, #5 <== NOT EXECUTED 3689c: e5803000 str r3, [r0] <== NOT EXECUTED 368a0: e3e07000 mvn r7, #0 <== NOT EXECUTED 368a4: eafffff8 b 3688c <msdos_file_rmnod+0x54> <== NOT EXECUTED
00036790 <msdos_file_stat>:
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
36790: e5902010 ldr r2, [r0, #16] <== NOT EXECUTED
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
36794: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
36798: e5925034 ldr r5, [r2, #52] ; 0x34 <== NOT EXECUTED
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
3679c: e1a04001 mov r4, r1 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
367a0: e3a01000 mov r1, #0 <== NOT EXECUTED
int
msdos_file_stat(
rtems_filesystem_location_info_t *loc,
struct stat *buf
)
{
367a4: e1a03000 mov r3, r0 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
367a8: e1a02001 mov r2, r1 <== NOT EXECUTED 367ac: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
struct stat *buf
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = loc->node_access;
367b0: e5936000 ldr r6, [r3] <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
367b4: ebff5742 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
367b8: e2507000 subs r7, r0, #0 <== NOT EXECUTED 367bc: 1a000018 bne 36824 <msdos_file_stat+0x94> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
367c0: e596200c ldr r2, [r6, #12] <== NOT EXECUTED
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
367c4: e3a03c82 mov r3, #33280 ; 0x8200 <== NOT EXECUTED 367c8: e2433001 sub r3, r3, #1 <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
367cc: e5842008 str r2, [r4, #8] <== NOT EXECUTED
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
367d0: e584300c str r3, [r4, #12] <== NOT EXECUTED
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
367d4: e5963018 ldr r3, [r6, #24] <== NOT EXECUTED
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
367d8: e1d520b0 ldrh r2, [r5] <== NOT EXECUTED
buf->st_dev = fs_info->fat.vol.dev;
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
buf->st_size = fat_fd->fat_file_size;
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
367dc: e1a014a3 lsr r1, r3, #9 <== NOT EXECUTED 367e0: e5841044 str r1, [r4, #68] ; 0x44 <== NOT EXECUTED
buf->st_blksize = fs_info->fat.vol.bps;
367e4: e5842040 str r2, [r4, #64] ; 0x40 <== NOT EXECUTED
buf->st_mtime = fat_fd->mtime;
367e8: e5962040 ldr r2, [r6, #64] ; 0x40 <== NOT EXECUTED 367ec: e5842030 str r2, [r4, #48] ; 0x30 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
buf->st_dev = fs_info->fat.vol.dev;
367f0: e2852054 add r2, r5, #84 ; 0x54 <== NOT EXECUTED
367f4: e8920006 ldm r2, {r1, r2} <== NOT EXECUTED
367f8: e8840006 stm r4, {r1, r2} <== NOT EXECUTED
buf->st_ino = fat_fd->ino;
buf->st_mode = S_IFREG | S_IRWXU | S_IRWXG | S_IRWXO;
buf->st_rdev = 0ll;
367fc: e3a01000 mov r1, #0 <== NOT EXECUTED 36800: e3a02000 mov r2, #0 <== NOT EXECUTED 36804: e5841018 str r1, [r4, #24] <== NOT EXECUTED 36808: e584201c str r2, [r4, #28] <== NOT EXECUTED
buf->st_size = fat_fd->fat_file_size;
3680c: e5843020 str r3, [r4, #32] <== NOT EXECUTED 36810: e5847024 str r7, [r4, #36] ; 0x24 <== NOT EXECUTED
buf->st_blocks = fat_fd->fat_file_size >> FAT_SECTOR512_BITS;
buf->st_blksize = fs_info->fat.vol.bps;
buf->st_mtime = fat_fd->mtime;
rtems_semaphore_release(fs_info->vol_sema);
36814: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED 36818: ebff5771 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 3681c: e1a00007 mov r0, r7 <== NOT EXECUTED
return RC_OK;
}
36820: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
fat_file_fd_t *fat_fd = loc->node_access;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
36824: eb0031f1 bl 42ff0 <__errno> <== NOT EXECUTED
36828: e3a03005 mov r3, #5 <== NOT EXECUTED
3682c: e5803000 str r3, [r0] <== NOT EXECUTED
36830: e3e00000 mvn r0, #0 <== NOT EXECUTED
36834: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00036904 <msdos_file_sync>:
msdos_file_sync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->file_info;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
36904: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
36908: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->file_info;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
3690c: e5936034 ldr r6, [r3, #52] ; 0x34 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36910: e3a01000 mov r1, #0 <== NOT EXECUTED
* RETURNS:
* RC_OK on success, or -1 if error occured (errno set appropriately)
*/
int
msdos_file_sync(rtems_libio_t *iop)
{
36914: e1a04000 mov r4, r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->file_info;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36918: e1a02001 mov r2, r1 <== NOT EXECUTED 3691c: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED
int
msdos_file_sync(rtems_libio_t *iop)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
fat_file_fd_t *fat_fd = iop->file_info;
36920: e5945038 ldr r5, [r4, #56] ; 0x38 <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36924: ebff56e6 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
36928: e3500000 cmp r0, #0 <== NOT EXECUTED 3692c: 1a00001f bne 369b0 <msdos_file_sync+0xac> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
/* synchronize file data */
rc = fat_file_datasync(iop->pathinfo.mt_entry, fat_fd);
36930: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 36934: e1a01005 mov r1, r5 <== NOT EXECUTED 36938: ebffba1d bl 251b4 <fat_file_datasync> <== NOT EXECUTED
if (rc != RC_OK)
3693c: e2507000 subs r7, r0, #0 <== NOT EXECUTED 36940: 1a000016 bne 369a0 <msdos_file_sync+0x9c> <== NOT EXECUTED
/*
* if fat-file descriptor is not marked "removed" - synchronize file
* metadata
*/
if (!FAT_FILE_IS_REMOVED(fat_fd))
36944: e5d53030 ldrb r3, [r5, #48] ; 0x30 <== NOT EXECUTED 36948: e3130001 tst r3, #1 <== NOT EXECUTED 3694c: 1a00000e bne 3698c <msdos_file_sync+0x88> <== NOT EXECUTED
{
rc = msdos_set_first_cluster_num(iop->pathinfo.mt_entry, fat_fd);
36950: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 36954: e1a01005 mov r1, r5 <== NOT EXECUTED 36958: eb000489 bl 37b84 <msdos_set_first_cluster_num> <== NOT EXECUTED
if (rc != RC_OK)
3695c: e2507000 subs r7, r0, #0 <== NOT EXECUTED 36960: 1a00000e bne 369a0 <msdos_file_sync+0x9c> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_file_size(iop->pathinfo.mt_entry, fat_fd);
36964: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 36968: e1a01005 mov r1, r5 <== NOT EXECUTED 3696c: eb000464 bl 37b04 <msdos_set_file_size> <== NOT EXECUTED
if (rc != RC_OK)
36970: e2507000 subs r7, r0, #0 <== NOT EXECUTED 36974: 1a000009 bne 369a0 <msdos_file_sync+0x9c> <== NOT EXECUTED
{
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
36978: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 3697c: e1a01005 mov r1, r5 <== NOT EXECUTED 36980: eb00050a bl 37db0 <msdos_set_dir_wrt_time_and_date> <== NOT EXECUTED
if (rc != RC_OK)
36984: e2507000 subs r7, r0, #0 <== NOT EXECUTED 36988: 1a000004 bne 369a0 <msdos_file_sync+0x9c> <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
return rc;
}
}
rtems_semaphore_release(fs_info->vol_sema);
3698c: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 36990: ebff5713 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 36994: e3a07000 mov r7, #0 <== NOT EXECUTED
return RC_OK;
}
36998: e1a00007 mov r0, r7 <== NOT EXECUTED
3699c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
return rc;
}
rc = msdos_set_dir_wrt_time_and_date(iop->pathinfo.mt_entry, fat_fd);
if (rc != RC_OK)
{
rtems_semaphore_release(fs_info->vol_sema);
369a0: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 369a4: ebff570e bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
}
}
rtems_semaphore_release(fs_info->vol_sema);
return RC_OK;
}
369a8: e1a00007 mov r0, r7 <== NOT EXECUTED
369ac: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
369b0: eb00318e bl 42ff0 <__errno> <== NOT EXECUTED 369b4: e3a03005 mov r3, #5 <== NOT EXECUTED 369b8: e5803000 str r3, [r0] <== NOT EXECUTED 369bc: e3e07000 mvn r7, #0 <== NOT EXECUTED 369c0: eafffff4 b 36998 <msdos_file_sync+0x94> <== NOT EXECUTED
00036b44 <msdos_file_write>:
* the number of bytes written on success, or -1 if error occured
* and errno set appropriately
*/
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
36b44: e92d4df0 push {r4, r5, r6, r7, r8, sl, fp, lr} <== NOT EXECUTED
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
36b48: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 36b4c: e5936034 ldr r6, [r3, #52] ; 0x34 <== NOT EXECUTED
* the number of bytes written on success, or -1 if error occured
* and errno set appropriately
*/
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
36b50: e1a07001 mov r7, r1 <== NOT EXECUTED
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36b54: e3a01000 mov r1, #0 <== NOT EXECUTED
* the number of bytes written on success, or -1 if error occured
* and errno set appropriately
*/
ssize_t
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
36b58: e1a04000 mov r4, r0 <== NOT EXECUTED 36b5c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 36b60: e1a0a002 mov sl, r2 <== NOT EXECUTED
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36b64: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 36b68: e1a02001 mov r2, r1 <== NOT EXECUTED
msdos_file_write(rtems_libio_t *iop,const void *buffer, size_t count)
{
ssize_t ret = 0;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = iop->pathinfo.mt_entry->fs_info;
fat_file_fd_t *fat_fd = iop->file_info;
36b6c: e5945038 ldr r5, [r4, #56] ; 0x38 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36b70: ebff5653 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
36b74: e2508000 subs r8, r0, #0 <== NOT EXECUTED 36b78: 1a00001b bne 36bec <msdos_file_write+0xa8> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
36b7c: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED 36b80: e594200c ldr r2, [r4, #12] <== NOT EXECUTED 36b84: e1a0300a mov r3, sl <== NOT EXECUTED 36b88: e1a01005 mov r1, r5 <== NOT EXECUTED 36b8c: e58d7000 str r7, [sp] <== NOT EXECUTED 36b90: ebffbad7 bl 256f4 <fat_file_write> <== NOT EXECUTED
buffer);
if (ret < 0)
36b94: e2507000 subs r7, r0, #0 <== NOT EXECUTED 36b98: ba000018 blt 36c00 <msdos_file_write+0xbc> <== NOT EXECUTED
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
if (iop->offset + ret > fat_fd->fat_file_size)
36b9c: e284200c add r2, r4, #12 <== NOT EXECUTED
36ba0: e8920006 ldm r2, {r1, r2} <== NOT EXECUTED
36ba4: e091a007 adds sl, r1, r7 <== NOT EXECUTED
36ba8: e0a2bfc7 adc fp, r2, r7, asr #31 <== NOT EXECUTED
36bac: e35b0000 cmp fp, #0 <== NOT EXECUTED
36bb0: e5953018 ldr r3, [r5, #24] <== NOT EXECUTED
36bb4: da000008 ble 36bdc <msdos_file_write+0x98> <== NOT EXECUTED
fat_fd->fat_file_size = iop->offset + ret;
36bb8: e0873001 add r3, r7, r1 <== NOT EXECUTED 36bbc: e5853018 str r3, [r5, #24] <== NOT EXECUTED 36bc0: e3a08000 mov r8, #0 <== NOT EXECUTED
iop->size = fat_fd->fat_file_size;
36bc4: e9840108 stmib r4, {r3, r8} <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
36bc8: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 36bcc: ebff5684 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return ret;
}
36bd0: e1a00007 mov r0, r7 <== NOT EXECUTED
36bd4: e28dd004 add sp, sp, #4 <== NOT EXECUTED
36bd8: e8bd8df0 pop {r4, r5, r6, r7, r8, sl, fp, pc} <== NOT EXECUTED
/*
* update file size in both fat-file descriptor and file control block if
* file was extended
*/
if (iop->offset + ret > fat_fd->fat_file_size)
36bdc: 1afffff8 bne 36bc4 <msdos_file_write+0x80> <== NOT EXECUTED 36be0: e15a0003 cmp sl, r3 <== NOT EXECUTED 36be4: 9afffff6 bls 36bc4 <msdos_file_write+0x80> <== NOT EXECUTED 36be8: eafffff2 b 36bb8 <msdos_file_write+0x74> <== NOT EXECUTED
fat_file_fd_t *fat_fd = iop->file_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
36bec: eb0030ff bl 42ff0 <__errno> <== NOT EXECUTED 36bf0: e3a03005 mov r3, #5 <== NOT EXECUTED 36bf4: e5803000 str r3, [r0] <== NOT EXECUTED 36bf8: e3e07000 mvn r7, #0 <== NOT EXECUTED 36bfc: eafffff3 b 36bd0 <msdos_file_write+0x8c> <== NOT EXECUTED
ret = fat_file_write(iop->pathinfo.mt_entry, fat_fd, iop->offset, count,
buffer);
if (ret < 0)
{
rtems_semaphore_release(fs_info->vol_sema);
36c00: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 36c04: ebff5676 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 36c08: e3e07000 mvn r7, #0 <== NOT EXECUTED
return -1;
36c0c: eaffffef b 36bd0 <msdos_file_write+0x8c> <== NOT EXECUTED
0004172c <msdos_filename_unix2dos>:
* Convert a unix filename to a DOS filename. Return -1 if wrong name is
* supplied.
*/
int
msdos_filename_unix2dos(const char *un, int unlen, char *dn)
{
4172c: e92d0030 push {r4, r5} <== NOT EXECUTED
41730: e3a03000 mov r3, #0 <== NOT EXECUTED
/* * Fill the dos filename string with blanks. These are DOS's pad * characters. */ for (i = 0; i <= 10; i++) dn[i] = ' ';
41734: e3a0c020 mov ip, #32 <== NOT EXECUTED 41738: e7c2c003 strb ip, [r2, r3] <== NOT EXECUTED
/*
* Fill the dos filename string with blanks. These are DOS's pad
* characters.
*/
for (i = 0; i <= 10; i++)
4173c: e2833001 add r3, r3, #1 <== NOT EXECUTED 41740: e353000b cmp r3, #11 <== NOT EXECUTED 41744: 1afffffb bne 41738 <msdos_filename_unix2dos+0xc> <== NOT EXECUTED
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
41748: e5d03000 ldrb r3, [r0] <== NOT EXECUTED 4174c: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED 41750: 13a0c000 movne ip, #0 <== NOT EXECUTED 41754: 03a0c001 moveq ip, #1 <== NOT EXECUTED 41758: e3510001 cmp r1, #1 <== NOT EXECUTED 4175c: 0353002e cmpeq r3, #46 ; 0x2e <== NOT EXECUTED
dn[0] = '.';
41760: 03a0302e moveq r3, #46 ; 0x2e <== NOT EXECUTED 41764: 05c23000 strbeq r3, [r2] <== NOT EXECUTED
/*
* The filenames "." and ".." are handled specially, since they
* don't follow dos filename rules.
*/
if (un[0] == '.' && unlen == 1) {
41768: 0a000025 beq 41804 <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
4176c: e35c0000 cmp ip, #0 <== NOT EXECUTED 41770: 1a00005c bne 418e8 <msdos_filename_unix2dos+0x1bc> <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
41774: e3510000 cmp r1, #0 <== NOT EXECUTED 41778: 0a000021 beq 41804 <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED 4177c: e35c0000 cmp ip, #0 <== NOT EXECUTED 41780: 1a000025 bne 4181c <msdos_filename_unix2dos+0xf0> <== NOT EXECUTED
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
41784: e3530000 cmp r3, #0 <== NOT EXECUTED 41788: 0a000028 beq 41830 <msdos_filename_unix2dos+0x104> <== NOT EXECUTED 4178c: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED 41790: 0a000026 beq 41830 <msdos_filename_unix2dos+0x104> <== NOT EXECUTED
if (msdos_map[c] == 0)
41794: e59f416c ldr r4, [pc, #364] ; 41908 <msdos_filename_unix2dos+0x1dc><== NOT EXECUTED 41798: e7d4c003 ldrb ip, [r4, r3] <== NOT EXECUTED 4179c: e35c0000 cmp ip, #0 <== NOT EXECUTED 417a0: 11a05000 movne r5, r0 <== NOT EXECUTED 417a4: 13a03000 movne r3, #0 <== NOT EXECUTED 417a8: 1a000008 bne 417d0 <msdos_filename_unix2dos+0xa4> <== NOT EXECUTED 417ac: ea00001f b 41830 <msdos_filename_unix2dos+0x104> <== NOT EXECUTED
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
417b0: e7d0c003 ldrb ip, [r0, r3] <== NOT EXECUTED 417b4: e35c0000 cmp ip, #0 <== NOT EXECUTED 417b8: 0a00001b beq 4182c <msdos_filename_unix2dos+0x100> <== NOT EXECUTED 417bc: e35c002e cmp ip, #46 ; 0x2e <== NOT EXECUTED 417c0: 0a000019 beq 4182c <msdos_filename_unix2dos+0x100> <== NOT EXECUTED
if (msdos_map[c] == 0)
417c4: e7d4c00c ldrb ip, [r4, ip] <== NOT EXECUTED 417c8: e35c0000 cmp ip, #0 <== NOT EXECUTED 417cc: 0a000016 beq 4182c <msdos_filename_unix2dos+0x100> <== NOT EXECUTED
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
417d0: e2511001 subs r1, r1, #1 <== NOT EXECUTED
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
417d4: e7c2c003 strb ip, [r2, r3] <== NOT EXECUTED
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
417d8: 03a0c000 moveq ip, #0 <== NOT EXECUTED 417dc: 13a0c001 movne ip, #1 <== NOT EXECUTED 417e0: e2833001 add r3, r3, #1 <== NOT EXECUTED 417e4: e3530007 cmp r3, #7 <== NOT EXECUTED 417e8: c3a0c000 movgt ip, #0 <== NOT EXECUTED 417ec: d20cc001 andle ip, ip, #1 <== NOT EXECUTED 417f0: e35c0000 cmp ip, #0 <== NOT EXECUTED
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
un++;
417f4: e2855001 add r5, r5, #1 <== NOT EXECUTED
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
417f8: 1affffec bne 417b0 <msdos_filename_unix2dos+0x84> <== NOT EXECUTED
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
417fc: e3510000 cmp r1, #0 <== NOT EXECUTED 41800: 1a00000b bne 41834 <msdos_filename_unix2dos+0x108> <== NOT EXECUTED
dn[i] = msdos_map[c];
un++;
unlen--;
}
return 0;
}
41804: e3a00000 mov r0, #0 <== NOT EXECUTED
41808: e8bd0030 pop {r4, r5} <== NOT EXECUTED
4180c: e12fff1e bx lr <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
41810: e5d03000 ldrb r3, [r0] <== NOT EXECUTED 41814: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED 41818: 1affffd9 bne 41784 <msdos_filename_unix2dos+0x58> <== NOT EXECUTED 4181c: e2511001 subs r1, r1, #1 <== NOT EXECUTED
un++;
41820: e2800001 add r0, r0, #1 <== NOT EXECUTED
}
/*
* Remove any dots from the start of a file name.
*/
while (unlen && (*un == '.')) {
41824: 1afffff9 bne 41810 <msdos_filename_unix2dos+0xe4> <== NOT EXECUTED 41828: eafffff5 b 41804 <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED
* Copy the unix filename into the dos filename string upto the end
* of string, a '.', or 8 characters. Whichever happens first stops
* us. This forms the name portion of the dos filename. Fold to
* upper case.
*/
for (i = 0; i <= 7 && unlen && (c = *un) && c != '.'; i++) {
4182c: e1a00005 mov r0, r5 <== NOT EXECUTED 41830: e1a05000 mov r5, r0 <== NOT EXECUTED
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
41834: e5d53000 ldrb r3, [r5] <== NOT EXECUTED 41838: e3530000 cmp r3, #0 <== NOT EXECUTED 4183c: 0afffff0 beq 41804 <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED
un++; unlen--; /* Make sure we've skipped over the dot before stopping. */ if (c == '.')
41840: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
un++;
41844: e285c001 add ip, r5, #1 <== NOT EXECUTED
unlen--;
41848: e2411001 sub r1, r1, #1 <== NOT EXECUTED
/* Make sure we've skipped over the dot before stopping. */ if (c == '.')
4184c: 0a000008 beq 41874 <msdos_filename_unix2dos+0x148> <== NOT EXECUTED
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
41850: e3510000 cmp r1, #0 <== NOT EXECUTED 41854: 0affffea beq 41804 <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED 41858: e5dc3000 ldrb r3, [ip] <== NOT EXECUTED 4185c: e3530000 cmp r3, #0 <== NOT EXECUTED 41860: 0affffe7 beq 41804 <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED
un++; unlen--; /* Make sure we've skipped over the dot before stopping. */ if (c == '.')
41864: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED
/*
* Strip any further characters up to a '.' or the end of the
* string.
*/
while (unlen && (c = *un)) {
un++;
41868: e28cc001 add ip, ip, #1 <== NOT EXECUTED
unlen--;
4186c: e2411001 sub r1, r1, #1 <== NOT EXECUTED
/* Make sure we've skipped over the dot before stopping. */ if (c == '.')
41870: 1afffff6 bne 41850 <msdos_filename_unix2dos+0x124> <== NOT EXECUTED
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
41874: e3510000 cmp r1, #0 <== NOT EXECUTED 41878: 0affffe1 beq 41804 <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED 4187c: e5dc3000 ldrb r3, [ip] <== NOT EXECUTED 41880: e3530000 cmp r3, #0 <== NOT EXECUTED 41884: 0affffde beq 41804 <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED
if (msdos_map[c] == 0)
41888: e59f4078 ldr r4, [pc, #120] ; 41908 <msdos_filename_unix2dos+0x1dc><== NOT EXECUTED 4188c: e7d40003 ldrb r0, [r4, r3] <== NOT EXECUTED 41890: e3500000 cmp r0, #0 <== NOT EXECUTED 41894: 13a03008 movne r3, #8 <== NOT EXECUTED 41898: 1a000007 bne 418bc <msdos_filename_unix2dos+0x190> <== NOT EXECUTED 4189c: eaffffd8 b 41804 <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
418a0: e5dc0001 ldrb r0, [ip, #1] <== NOT EXECUTED 418a4: e3500000 cmp r0, #0 <== NOT EXECUTED 418a8: 0affffd5 beq 41804 <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED
if (msdos_map[c] == 0)
418ac: e7d40000 ldrb r0, [r4, r0] <== NOT EXECUTED 418b0: e3500000 cmp r0, #0 <== NOT EXECUTED 418b4: e28cc001 add ip, ip, #1 <== NOT EXECUTED 418b8: 0affffd1 beq 41804 <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
418bc: e2511001 subs r1, r1, #1 <== NOT EXECUTED
if (msdos_map[c] == 0)
break;
dn[i] = msdos_map[c];
418c0: e7c20003 strb r0, [r2, r3] <== NOT EXECUTED
/*
* Copy in the extension part of the name, if any. Force to upper
* case. Note that the extension is allowed to contain '.'s.
* Filenames in this form are probably inaccessable under dos.
*/
for (i = 8; i <= 10 && unlen && (c = *un); i++) {
418c4: 03a00000 moveq r0, #0 <== NOT EXECUTED 418c8: 13a00001 movne r0, #1 <== NOT EXECUTED 418cc: e2833001 add r3, r3, #1 <== NOT EXECUTED 418d0: e353000a cmp r3, #10 <== NOT EXECUTED 418d4: c3a00000 movgt r0, #0 <== NOT EXECUTED 418d8: d2000001 andle r0, r0, #1 <== NOT EXECUTED 418dc: e3500000 cmp r0, #0 <== NOT EXECUTED 418e0: 1affffee bne 418a0 <msdos_filename_unix2dos+0x174> <== NOT EXECUTED 418e4: eaffffc6 b 41804 <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED
*/
if (un[0] == '.' && unlen == 1) {
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
418e8: e5d04001 ldrb r4, [r0, #1] <== NOT EXECUTED 418ec: e354002e cmp r4, #46 ; 0x2e <== NOT EXECUTED 418f0: 03510002 cmpeq r1, #2 <== NOT EXECUTED
dn[0] = '.';
418f4: 03a0302e moveq r3, #46 ; 0x2e <== NOT EXECUTED
dn[1] = '.';
418f8: 05c23001 strbeq r3, [r2, #1] <== NOT EXECUTED
if (un[0] == '.' && unlen == 1) {
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
dn[0] = '.';
418fc: 05c23000 strbeq r3, [r2] <== NOT EXECUTED
*/
if (un[0] == '.' && unlen == 1) {
dn[0] = '.';
return 0;
}
if (un[0] == '.' && un[1] == '.' && unlen == 2) {
41900: 1affff9b bne 41774 <msdos_filename_unix2dos+0x48> <== NOT EXECUTED 41904: eaffffbe b 41804 <msdos_filename_unix2dos+0xd8> <== NOT EXECUTED
000384b8 <msdos_find_name>:
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
384b8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
384bc: e24dd040 sub sp, sp, #64 ; 0x40 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
384c0: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
384c4: e28d500c add r5, sp, #12 <== NOT EXECUTED
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
384c8: e3a04000 mov r4, #0 <== NOT EXECUTED
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
384cc: e285c008 add ip, r5, #8 <== NOT EXECUTED
const char *name,
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
384d0: e593a034 ldr sl, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
384d4: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 384d8: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 384dc: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 384e0: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 384e4: e48c4004 str r4, [ip], #4 <== NOT EXECUTED
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
384e8: e1a07001 mov r7, r1 <== NOT EXECUTED
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
384ec: e58c4000 str r4, [ip] <== NOT EXECUTED
name_type = msdos_long_to_short (name,
384f0: e1a01002 mov r1, r2 <== NOT EXECUTED
msdos_find_name(
rtems_filesystem_location_info_t *parent_loc,
const char *name,
int name_len
)
{
384f4: e1a06000 mov r6, r0 <== NOT EXECUTED 384f8: e1a08002 mov r8, r2 <== NOT EXECUTED
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
name_type = msdos_long_to_short (name,
384fc: e3a0300b mov r3, #11 <== NOT EXECUTED 38500: e1a02005 mov r2, r5 <== NOT EXECUTED 38504: e1a00007 mov r0, r7 <== NOT EXECUTED
int name_len
)
{
int rc = RC_OK;
msdos_fs_info_t *fs_info = parent_loc->mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
38508: e58d403c str r4, [sp, #60] ; 0x3c <== NOT EXECUTED
fat_dir_pos_t dir_pos;
unsigned short time_val = 0;
unsigned short date = 0;
char node_entry[MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE];
memset(node_entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
3850c: e58d400c str r4, [sp, #12] <== NOT EXECUTED 38510: e58d4010 str r4, [sp, #16] <== NOT EXECUTED
name_type = msdos_long_to_short (name,
38514: ebfffea6 bl 37fb4 <msdos_long_to_short> <== NOT EXECUTED
/*
* find the node which correspondes to the name in the directory pointed by
* 'parent_loc'
*/
rc = msdos_get_name_node(parent_loc, false, name, name_len, name_type,
38518: e1a01004 mov r1, r4 <== NOT EXECUTED
3851c: e58d0000 str r0, [sp] <== NOT EXECUTED
38520: e1a02007 mov r2, r7 <== NOT EXECUTED
38524: e1a03008 mov r3, r8 <== NOT EXECUTED
38528: e28d402c add r4, sp, #44 ; 0x2c <== NOT EXECUTED
3852c: e1a00006 mov r0, r6 <== NOT EXECUTED
38530: e98d0030 stmib sp, {r4, r5} <== NOT EXECUTED
38534: ebffffa7 bl 383d8 <msdos_get_name_node> <== NOT EXECUTED
&dir_pos, node_entry);
if (rc != RC_OK)
38538: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3853c: 1a000019 bne 385a8 <msdos_find_name+0xf0> <== NOT EXECUTED
return rc;
if (((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_VOLUME_ID) ||
38540: e5dd3017 ldrb r3, [sp, #23] <== NOT EXECUTED 38544: e3130008 tst r3, #8 <== NOT EXECUTED 38548: 1a000019 bne 385b4 <msdos_find_name+0xfc> <== NOT EXECUTED 3854c: e203303f and r3, r3, #63 ; 0x3f <== NOT EXECUTED 38550: e353000f cmp r3, #15 <== NOT EXECUTED 38554: 0a000016 beq 385b4 <msdos_find_name+0xfc> <== NOT EXECUTED
((*MSDOS_DIR_ATTR(node_entry) & MSDOS_ATTR_LFN_MASK) == MSDOS_ATTR_LFN))
return MSDOS_NAME_NOT_FOUND_ERR;
/* open fat-file corresponded to the found node */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
38558: e5960010 ldr r0, [r6, #16] <== NOT EXECUTED 3855c: e1a01004 mov r1, r4 <== NOT EXECUTED 38560: e28d203c add r2, sp, #60 ; 0x3c <== NOT EXECUTED 38564: ebffb5a5 bl 25c00 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
38568: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3856c: 1a00000d bne 385a8 <msdos_find_name+0xf0> <== NOT EXECUTED
return rc;
fat_fd->dir_pos = dir_pos;
38570: e59d703c ldr r7, [sp, #60] ; 0x3c <== NOT EXECUTED
* size and first cluster num to the disk after each write operation
* (even if one byte is written - that is TOO slow) because
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
38574: e5978008 ldr r8, [r7, #8] <== NOT EXECUTED
/* open fat-file corresponded to the found node */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->dir_pos = dir_pos;
38578: e894000f ldm r4, {r0, r1, r2, r3} <== NOT EXECUTED
3857c: e287c020 add ip, r7, #32 <== NOT EXECUTED
* size and first cluster num to the disk after each write operation
* (even if one byte is written - that is TOO slow) because
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
38580: e3580001 cmp r8, #1 <== NOT EXECUTED
/* open fat-file corresponded to the found node */
rc = fat_file_open(parent_loc->mt_entry, &dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->dir_pos = dir_pos;
38584: e88c000f stm ip, {r0, r1, r2, r3} <== NOT EXECUTED
* size and first cluster num to the disk after each write operation
* (even if one byte is written - that is TOO slow) because
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
38588: 0a00000c beq 385c0 <msdos_find_name+0x108> <== NOT EXECUTED
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
}
}
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
3858c: e5960010 ldr r0, [r6, #16] <== NOT EXECUTED 38590: e5961000 ldr r1, [r6] <== NOT EXECUTED 38594: ebffb56f bl 25b58 <fat_file_close> <== NOT EXECUTED
if (rc != RC_OK)
38598: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3859c: 1a000030 bne 38664 <msdos_find_name+0x1ac> <== NOT EXECUTED
fat_file_close(parent_loc->mt_entry, fat_fd);
return rc;
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
385a0: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED 385a4: e5863000 str r3, [r6] <== NOT EXECUTED
return rc;
}
385a8: e1a00007 mov r0, r7 <== NOT EXECUTED
385ac: e28dd040 add sp, sp, #64 ; 0x40 <== NOT EXECUTED
385b0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
}
/* update node_info_ptr field */
parent_loc->node_access = fat_fd;
return rc;
385b4: e3a07c7d mov r7, #32000 ; 0x7d00 <== NOT EXECUTED 385b8: e2877001 add r7, r7, #1 <== NOT EXECUTED 385bc: eafffff9 b 385a8 <msdos_find_name+0xf0> <== NOT EXECUTED
* otherwise real values of these fields stored in fat-file descriptor
* may be accidentally rewritten with wrong values stored on the disk
*/
if (fat_fd->links_num == 1)
{
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(node_entry);
385c0: e1d521b4 ldrh r2, [r5, #20] <== NOT EXECUTED 385c4: e1d531ba ldrh r3, [r5, #26] <== NOT EXECUTED 385c8: e1833802 orr r3, r3, r2, lsl #16 <== NOT EXECUTED 385cc: e587301c str r3, [r7, #28] <== NOT EXECUTED
time_val = *MSDOS_DIR_WRITE_TIME(node_entry);
date = *MSDOS_DIR_WRITE_DATE(node_entry);
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
385d0: e1d501b8 ldrh r0, [r5, #24] <== NOT EXECUTED 385d4: e1d511b6 ldrh r1, [r5, #22] <== NOT EXECUTED 385d8: eb00240b bl 4160c <msdos_date_dos2unix> <== NOT EXECUTED 385dc: e5870040 str r0, [r7, #64] ; 0x40 <== NOT EXECUTED
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
385e0: e5dd3017 ldrb r3, [sp, #23] <== NOT EXECUTED 385e4: e3130010 tst r3, #16 <== NOT EXECUTED 385e8: 1a000014 bne 38640 <msdos_find_name+0x188> <== NOT EXECUTED
return rc;
}
}
else
{
fat_fd->fat_file_size = CF_LE_L(*MSDOS_DIR_FILE_SIZE(node_entry));
385ec: e595201c ldr r2, [r5, #28] <== NOT EXECUTED 385f0: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED 385f4: e5832018 str r2, [r3, #24] <== NOT EXECUTED
fat_fd->fat_file_type = FAT_FILE;
385f8: e3a02005 mov r2, #5 <== NOT EXECUTED 385fc: e5832010 str r2, [r3, #16] <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
38600: e3e02000 mvn r2, #0 <== NOT EXECUTED 38604: e5832014 str r2, [r3, #20] <== NOT EXECUTED
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
38608: e5932018 ldr r2, [r3, #24] <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
3860c: e593101c ldr r1, [r3, #28] <== NOT EXECUTED
fat_fd->fat_file_type = FAT_FILE;
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
38610: e3a00000 mov r0, #0 <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
38614: e3520000 cmp r2, #0 <== NOT EXECUTED
fat_fd->fat_file_type = FAT_FILE;
fat_fd->size_limit = MSDOS_MAX_FILE_SIZE;
}
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
38618: e5830034 str r0, [r3, #52] ; 0x34 <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
3861c: e5831038 str r1, [r3, #56] ; 0x38 <== NOT EXECUTED
if ((fat_fd->fat_file_size != 0) &&
38620: 0a000003 beq 38634 <msdos_find_name+0x17c> <== NOT EXECUTED
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
38624: e1da00b6 ldrh r0, [sl, #6] <== NOT EXECUTED 38628: e1520000 cmp r2, r0 <== NOT EXECUTED
{
fat_fd->map.last_cln = fat_fd->cln;
3862c: 9583103c strls r1, [r3, #60] ; 0x3c <== NOT EXECUTED
/* these data is not actual for zero-length fat-file */
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
if ((fat_fd->fat_file_size != 0) &&
(fat_fd->fat_file_size <= fs_info->fat.vol.bpc))
38630: 9affffd5 bls 3858c <msdos_find_name+0xd4> <== NOT EXECUTED
{
fat_fd->map.last_cln = fat_fd->cln;
}
else
{
fat_fd->map.last_cln = FAT_UNDEFINED_VALUE;
38634: e3e02000 mvn r2, #0 <== NOT EXECUTED 38638: e583203c str r2, [r3, #60] ; 0x3c <== NOT EXECUTED 3863c: eaffffd2 b 3858c <msdos_find_name+0xd4> <== NOT EXECUTED
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
{
fat_fd->fat_file_type = FAT_DIRECTORY;
38640: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
38644: e3a03602 mov r3, #2097152 ; 0x200000 <== NOT EXECUTED 38648: e5813014 str r3, [r1, #20] <== NOT EXECUTED
fat_fd->mtime = msdos_date_dos2unix(CF_LE_W(date), CF_LE_W(time_val));
if ((*MSDOS_DIR_ATTR(node_entry)) & MSDOS_ATTR_DIRECTORY)
{
fat_fd->fat_file_type = FAT_DIRECTORY;
3864c: e5818010 str r8, [r1, #16] <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
rc = fat_file_size(parent_loc->mt_entry, fat_fd);
38650: e5960010 ldr r0, [r6, #16] <== NOT EXECUTED 38654: ebffb274 bl 2502c <fat_file_size> <== NOT EXECUTED
if (rc != RC_OK)
38658: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3865c: 059d303c ldreq r3, [sp, #60] ; 0x3c <== NOT EXECUTED 38660: 0affffe8 beq 38608 <msdos_find_name+0x150> <== NOT EXECUTED
/* close fat-file corresponded to the node we searched in */
rc = fat_file_close(parent_loc->mt_entry, parent_loc->node_access);
if (rc != RC_OK)
{
fat_file_close(parent_loc->mt_entry, fat_fd);
38664: e5960010 ldr r0, [r6, #16] <== NOT EXECUTED 38668: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED 3866c: ebffb539 bl 25b58 <fat_file_close> <== NOT EXECUTED
return rc;
38670: eaffffcc b 385a8 <msdos_find_name+0xf0> <== NOT EXECUTED
00036fd0 <msdos_find_name_in_fat_file>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
36fd0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
36fd4: e24dd060 sub sp, sp, #96 ; 0x60 <== NOT EXECUTED
36fd8: e58d0030 str r0, [sp, #48] ; 0x30 <== NOT EXECUTED
36fdc: e58d1028 str r1, [sp, #40] ; 0x28 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
36fe0: e59d1030 ldr r1, [sp, #48] ; 0x30 <== NOT EXECUTED
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
36fe4: e59d0084 ldr r0, [sp, #132] ; 0x84 <== NOT EXECUTED
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
36fe8: e5911034 ldr r1, [r1, #52] ; 0x34 <== NOT EXECUTED
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
36fec: e20220ff and r2, r2, #255 ; 0xff <== NOT EXECUTED
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
36ff0: e3500000 cmp r0, #0 <== NOT EXECUTED
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
36ff4: e58d3040 str r3, [sp, #64] ; 0x40 <== NOT EXECUTED 36ff8: e58d200c str r2, [sp, #12] <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
36ffc: e58d1024 str r1, [sp, #36] ; 0x24 <== NOT EXECUTED
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
37000: da00025f ble 37984 <msdos_find_name_in_fat_file+0x9b4> <== NOT EXECUTED
* is short still check for possible long entries with the short name.
*
* In PR1491 we need to have a LFN for a short file name entry. To
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
37004: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
37008: e59dc08c ldr ip, [sp, #140] ; 0x8c <== NOT EXECUTED
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
3700c: e3a03000 mov r3, #0 <== NOT EXECUTED 37010: e3520000 cmp r2, #0 <== NOT EXECUTED
dir_pos->sname.ofs = 0; dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
37014: e3e02000 mvn r2, #0 <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
37018: e58c200c str r2, [ip, #12] <== NOT EXECUTED
static inline void
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
3701c: e58c3000 str r3, [ip] <== NOT EXECUTED
dir_pos->sname.ofs = 0;
37020: e58c3004 str r3, [ip, #4] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
37024: e58c2008 str r2, [ip, #8] <== NOT EXECUTED 37028: 0a000002 beq 37038 <msdos_find_name_in_fat_file+0x68> <== NOT EXECUTED 3702c: e59d0088 ldr r0, [sp, #136] ; 0x88 <== NOT EXECUTED 37030: e3500001 cmp r0, #1 <== NOT EXECUTED 37034: 0a000005 beq 37050 <msdos_find_name_in_fat_file+0x80> <== NOT EXECUTED
lfn_entries = 0;
else
lfn_entries =
37038: e59d1084 ldr r1, [sp, #132] ; 0x84 <== NOT EXECUTED 3703c: e281300c add r3, r1, #12 <== NOT EXECUTED 37040: e59f1954 ldr r1, [pc, #2388] ; 3799c <msdos_find_name_in_fat_file+0x9cc><== NOT EXECUTED 37044: e0c2c391 smull ip, r2, r1, r3 <== NOT EXECUTED 37048: e1a03fc3 asr r3, r3, #31 <== NOT EXECUTED 3704c: e0633142 rsb r3, r3, r2, asr #2 <== NOT EXECUTED
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
37050: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED
* test this make this test always fail, ie add "0 &&".
*/
if (create_node && (name_type == MSDOS_NAME_SHORT))
lfn_entries = 0;
else
lfn_entries =
37054: e58d3038 str r3, [sp, #56] ; 0x38 <== NOT EXECUTED
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
37058: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED 3705c: e3530001 cmp r3, #1 <== NOT EXECUTED 37060: 0a00016f beq 37624 <msdos_find_name_in_fat_file+0x654> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
37064: e59d2024 ldr r2, [sp, #36] ; 0x24 <== NOT EXECUTED 37068: e1d290b6 ldrh r9, [r2, #6] <== NOT EXECUTED
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
3706c: e59d0038 ldr r0, [sp, #56] ; 0x38 <== NOT EXECUTED
assert(name_len > 0);
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
37070: e3a03000 mov r3, #0 <== NOT EXECUTED 37074: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 37078: e3a0a000 mov sl, #0 <== NOT EXECUTED 3707c: e58d301c str r3, [sp, #28] <== NOT EXECUTED
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
37080: e2800001 add r0, r0, #1 <== NOT EXECUTED
assert(name_len > 0);
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
37084: e3e03000 mvn r3, #0 <== NOT EXECUTED 37088: e58d3058 str r3, [sp, #88] ; 0x58 <== NOT EXECUTED 3708c: e58d3054 str r3, [sp, #84] ; 0x54 <== NOT EXECUTED 37090: e59cb098 ldr fp, [ip, #152] ; 0x98 <== NOT EXECUTED 37094: e58da014 str sl, [sp, #20] <== NOT EXECUTED 37098: e58da010 str sl, [sp, #16] <== NOT EXECUTED 3709c: e58da02c str sl, [sp, #44] ; 0x2c <== NOT EXECUTED
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
370a0: e58d0020 str r0, [sp, #32] <== NOT EXECUTED 370a4: e58da034 str sl, [sp, #52] ; 0x34 <== NOT EXECUTED
assert(name_len > 0);
fat_dir_pos_init(dir_pos);
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
370a8: e1a0700a mov r7, sl <== NOT EXECUTED 370ac: e1a0600a mov r6, sl <== NOT EXECUTED 370b0: e1a0800a mov r8, sl <== NOT EXECUTED
/*
* Scan the directory seeing if the file is present. While
* doing this see if a suitable location can be found to
* create the entry if the name is not found.
*/
while ((ret = fat_file_read(mt_entry, fat_fd, (dir_offset * bts2rd),
370b4: e59d0030 ldr r0, [sp, #48] ; 0x30 <== NOT EXECUTED 370b8: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED 370bc: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 370c0: e1a03009 mov r3, r9 <== NOT EXECUTED 370c4: e58db000 str fp, [sp] <== NOT EXECUTED 370c8: ebffba1f bl 2594c <fat_file_read> <== NOT EXECUTED 370cc: e3500000 cmp r0, #0 <== NOT EXECUTED 370d0: 0a0001fa beq 378c0 <msdos_find_name_in_fat_file+0x8f0> <== NOT EXECUTED
bool remainder_empty = false;
#if MSDOS_FIND_PRINT
printf ("MSFS:[2] dir_offset:%li\n", dir_offset);
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
370d4: e350001f cmp r0, #31 <== NOT EXECUTED 370d8: da0001db ble 3784c <msdos_find_name_in_fat_file+0x87c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
370dc: e1500009 cmp r0, r9 <== NOT EXECUTED 370e0: 1a000221 bne 3796c <msdos_find_name_in_fat_file+0x99c> <== NOT EXECUTED 370e4: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 370e8: e591b098 ldr fp, [r1, #152] ; 0x98 <== NOT EXECUTED 370ec: e3a05000 mov r5, #0 <== NOT EXECUTED 370f0: e1a0400b mov r4, fp <== NOT EXECUTED 370f4: e59d1034 ldr r1, [sp, #52] ; 0x34 <== NOT EXECUTED 370f8: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED 370fc: ea000018 b 37164 <msdos_find_name_in_fat_file+0x194> <== NOT EXECUTED
* A valid entry so handle it.
*
* If empty space has not been found we need to start the
* count again.
*/
if (create_node && !empty_space_found)
37100: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 37104: e3530000 cmp r3, #0 <== NOT EXECUTED 37108: 0a000002 beq 37118 <msdos_find_name_in_fat_file+0x148> <== NOT EXECUTED 3710c: e35a0000 cmp sl, #0 <== NOT EXECUTED 37110: 01a0600a moveq r6, sl <== NOT EXECUTED 37114: 01a0700a moveq r7, sl <== NOT EXECUTED
/*
* Check the attribute to see if the entry is for a long
* file name.
*/
if ((*MSDOS_DIR_ATTR(entry) & MSDOS_ATTR_LFN_MASK) ==
37118: e5d4300b ldrb r3, [r4, #11] <== NOT EXECUTED 3711c: e203303f and r3, r3, #63 ; 0x3f <== NOT EXECUTED 37120: e353000f cmp r3, #15 <== NOT EXECUTED 37124: 0a00005a beq 37294 <msdos_find_name_in_fat_file+0x2c4> <== NOT EXECUTED
* If a LFN has been found and it matched check the
* entries have all been found and the checksum is
* correct. If this is the case return the short file
* name entry.
*/
if (lfn_matched)
37128: e3510000 cmp r1, #0 <== NOT EXECUTED 3712c: 13a03000 movne r3, #0 <== NOT EXECUTED 37130: 11a01003 movne r1, r3 <== NOT EXECUTED 37134: 11a00003 movne r0, r3 <== NOT EXECUTED 37138: 1a000027 bne 371dc <msdos_find_name_in_fat_file+0x20c> <== NOT EXECUTED
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
3713c: e59d3088 ldr r3, [sp, #136] ; 0x88 <== NOT EXECUTED 37140: e3530001 cmp r3, #1 <== NOT EXECUTED 37144: 0a00005e beq 372c4 <msdos_find_name_in_fat_file+0x2f4> <== NOT EXECUTED
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
37148: e3e02000 mvn r2, #0 <== NOT EXECUTED 3714c: e58d2054 str r2, [sp, #84] ; 0x54 <== NOT EXECUTED 37150: e3a01000 mov r1, #0 <== NOT EXECUTED
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
37154: e2855020 add r5, r5, #32 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
37158: e1590005 cmp r9, r5 <== NOT EXECUTED
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
3715c: e2844020 add r4, r4, #32 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
37160: 9a000012 bls 371b0 <msdos_find_name_in_fat_file+0x1e0> <== NOT EXECUTED
/*
* See if the entry is empty or the remainder of the directory is
* empty ? Localise to make the code read better.
*/
bool entry_empty = (*MSDOS_DIR_ENTRY_TYPE(entry) ==
37164: e7db2005 ldrb r2, [fp, r5] <== NOT EXECUTED
* to here and write the long file name if this is the start of
* a series of empty entries. If empty_space_count is 0 then
* we are currently not inside an empty series of entries. It
* is a count of empty entries.
*/
if (empty_space_count == 0)
37168: e3570000 cmp r7, #0 <== NOT EXECUTED 3716c: 01a0800c moveq r8, ip <== NOT EXECUTED 37170: 01a06005 moveq r6, r5 <== NOT EXECUTED
{
empty_space_entry = dir_entry;
empty_space_offset = dir_offset;
}
if (remainder_empty)
37174: e3520000 cmp r2, #0 <== NOT EXECUTED 37178: 0a00009a beq 373e8 <msdos_find_name_in_fat_file+0x418> <== NOT EXECUTED
printf ("MSFS:[3.2] esf:%i esc%i\n", empty_space_found, empty_space_count);
#endif
}
break;
}
else if (entry_empty)
3717c: e35200e5 cmp r2, #229 ; 0xe5 <== NOT EXECUTED 37180: 1affffde bne 37100 <msdos_find_name_in_fat_file+0x130> <== NOT EXECUTED
{
if (create_node)
37184: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 37188: e3530000 cmp r3, #0 <== NOT EXECUTED 3718c: 0afffff0 beq 37154 <msdos_find_name_in_fat_file+0x184> <== NOT EXECUTED
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
37190: e59d0020 ldr r0, [sp, #32] <== NOT EXECUTED
if (create_node)
{
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
37194: e2877001 add r7, r7, #1 <== NOT EXECUTED
if (empty_space_count == (lfn_entries + 1))
37198: e1500007 cmp r0, r7 <== NOT EXECUTED
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
3719c: e2855020 add r5, r5, #32 <== NOT EXECUTED
/*
* Remainder is not empty so is this entry empty ?
*/
empty_space_count++;
if (empty_space_count == (lfn_entries + 1))
371a0: 03a0a001 moveq sl, #1 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
371a4: e1590005 cmp r9, r5 <== NOT EXECUTED
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
371a8: e2844020 add r4, r4, #32 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
371ac: 8affffec bhi 37164 <msdos_find_name_in_fat_file+0x194> <== NOT EXECUTED 371b0: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
}
if (remainder_empty)
break;
dir_offset++;
371b4: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
371b8: e0833009 add r3, r3, r9 <== NOT EXECUTED
}
if (remainder_empty)
break;
dir_offset++;
371bc: e28cc001 add ip, ip, #1 <== NOT EXECUTED 371c0: e58d1034 str r1, [sp, #52] ; 0x34 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
/* have to look at the DIR_NAME as "raw" 8-bit data */
for (dir_entry = 0;
371c4: e58d301c str r3, [sp, #28] <== NOT EXECUTED
}
if (remainder_empty)
break;
dir_offset++;
371c8: e58dc02c str ip, [sp, #44] ; 0x2c <== NOT EXECUTED 371cc: eaffffb8 b 370b4 <msdos_find_name_in_fat_file+0xe4> <== NOT EXECUTED
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
371d0: e2100001 ands r0, r0, #1 <== NOT EXECUTED 371d4: e7d42003 ldrb r2, [r4, r3] <== NOT EXECUTED 371d8: 13a00080 movne r0, #128 ; 0x80 <== NOT EXECUTED 371dc: e0820000 add r0, r2, r0 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
371e0: e2833001 add r3, r3, #1 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
371e4: e08000a1 add r0, r0, r1, lsr #1 <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
371e8: e353000b cmp r3, #11 <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
371ec: e20010ff and r1, r0, #255 ; 0xff <== NOT EXECUTED
{
uint8_t cs = 0;
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(entry);
int i;
for (i = 0; i < MSDOS_SHORT_NAME_LEN; i++, p++)
371f0: 1afffff6 bne 371d0 <msdos_find_name_in_fat_file+0x200> <== NOT EXECUTED
cs = ((cs & 1) ? 0x80 : 0) + (cs >> 1) + *p;
if (lfn_entry || (lfn_checksum != cs))
371f4: e28d0010 add r0, sp, #16 <== NOT EXECUTED
371f8: e8900005 ldm r0, {r0, r2} <== NOT EXECUTED
371fc: e3520000 cmp r2, #0 <== NOT EXECUTED
37200: 01500001 cmpeq r0, r1 <== NOT EXECUTED
37204: 1affffcc bne 3713c <msdos_find_name_in_fat_file+0x16c> <== NOT EXECUTED
#endif
/*
* We get the entry we looked for - fill the position
* structure and the 32 bytes of the short entry
*/
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
37208: e59dc08c ldr ip, [sp, #140] ; 0x8c <== NOT EXECUTED 3720c: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 37210: e59d0030 ldr r0, [sp, #48] ; 0x30 <== NOT EXECUTED 37214: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED 37218: e3a02001 mov r2, #1 <== NOT EXECUTED 3721c: e58dc000 str ip, [sp] <== NOT EXECUTED 37220: ebffb83f bl 25324 <fat_file_ioctl> <== NOT EXECUTED
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
37224: e3500000 cmp r0, #0 <== NOT EXECUTED 37228: 1a000017 bne 3728c <msdos_find_name_in_fat_file+0x2bc> <== NOT EXECUTED
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
3722c: e59d3054 ldr r3, [sp, #84] ; 0x54 <== NOT EXECUTED
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
37230: e59d008c ldr r0, [sp, #140] ; 0x8c <== NOT EXECUTED
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
37234: e3730001 cmn r3, #1 <== NOT EXECUTED
dir_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
37238: e5805004 str r5, [r0, #4] <== NOT EXECUTED
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
3723c: 0a000009 beq 37268 <msdos_find_name_in_fat_file+0x298> <== NOT EXECUTED
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
37240: e28dc054 add ip, sp, #84 ; 0x54 <== NOT EXECUTED 37244: e0030399 mul r3, r9, r3 <== NOT EXECUTED 37248: e59d0030 ldr r0, [sp, #48] ; 0x30 <== NOT EXECUTED 3724c: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED 37250: e3a02001 mov r2, #1 <== NOT EXECUTED 37254: e58dc000 str ip, [sp] <== NOT EXECUTED 37258: ebffb831 bl 25324 <fat_file_ioctl> <== NOT EXECUTED
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
3725c: e3500000 cmp r0, #0 <== NOT EXECUTED 37260: 1a000009 bne 3728c <msdos_find_name_in_fat_file+0x2bc> <== NOT EXECUTED 37264: e59d3054 ldr r3, [sp, #84] ; 0x54 <== NOT EXECUTED
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
37268: e59d108c ldr r1, [sp, #140] ; 0x8c <== NOT EXECUTED 3726c: e59d2058 ldr r2, [sp, #88] ; 0x58 <== NOT EXECUTED
&lfn_start.cln);
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
37270: e5813008 str r3, [r1, #8] <== NOT EXECUTED
dir_pos->lname.ofs = lfn_start.ofs;
37274: e581200c str r2, [r1, #12] <== NOT EXECUTED
memcpy(name_dir_entry, entry,
37278: e59d0090 ldr r0, [sp, #144] ; 0x90 <== NOT EXECUTED 3727c: e1a01004 mov r1, r4 <== NOT EXECUTED 37280: e3a02020 mov r2, #32 <== NOT EXECUTED 37284: eb003c09 bl 462b0 <memcpy> <== NOT EXECUTED 37288: e3a00000 mov r0, #0 <== NOT EXECUTED
empty_space_entry = 0;
read_cluster = true;
}
return 0;
}
3728c: e28dd060 add sp, sp, #96 ; 0x60 <== NOT EXECUTED
37290: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
#endif
/*
* If we are not already processing a LFN see if this is
* the first entry of a LFN ?
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
37294: e59d3054 ldr r3, [sp, #84] ; 0x54 <== NOT EXECUTED 37298: e3730001 cmn r3, #1 <== NOT EXECUTED 3729c: 159d3010 ldrne r3, [sp, #16] <== NOT EXECUTED 372a0: 0a000013 beq 372f4 <msdos_find_name_in_fat_file+0x324> <== NOT EXECUTED
* If the entry number or the check sum do not match
* forget this series of long directory entries. These
* could be orphaned entries depending on the history
* of the disk.
*/
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
372a4: e202003f and r0, r2, #63 ; 0x3f <== NOT EXECUTED 372a8: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 372ac: e1500002 cmp r0, r2 <== NOT EXECUTED 372b0: 0a000017 beq 37314 <msdos_find_name_in_fat_file+0x344> <== NOT EXECUTED
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
{
#if MSDOS_FIND_PRINT
printf ("MSFS:[4.4] no match\n");
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
372b4: e3e00000 mvn r0, #0 <== NOT EXECUTED 372b8: e58d0054 str r0, [sp, #84] ; 0x54 <== NOT EXECUTED 372bc: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
continue;
372c0: eaffffa3 b 37154 <msdos_find_name_in_fat_file+0x184> <== NOT EXECUTED
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
372c4: e59d3054 ldr r3, [sp, #84] ; 0x54 <== NOT EXECUTED 372c8: e3730001 cmn r3, #1 <== NOT EXECUTED 372cc: 1affff9d bne 37148 <msdos_find_name_in_fat_file+0x178> <== NOT EXECUTED
((name_type == MSDOS_NAME_SHORT) &&
(lfn_start.cln == FAT_FILE_SHORT_NAME) &&
(memcmp(MSDOS_DIR_NAME(entry),
372d0: e1a00004 mov r0, r4 <== NOT EXECUTED 372d4: e59d1090 ldr r1, [sp, #144] ; 0x90 <== NOT EXECUTED 372d8: e3a0200b mov r2, #11 <== NOT EXECUTED 372dc: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 372e0: eb003bc8 bl 46208 <memcmp> <== NOT EXECUTED
* short and they match then we have the entry. We will not
* match a long file name against a short file name because
* a long file name that generates a matching short file
* name is not a long file name.
*/
if (lfn_matched ||
372e4: e3500000 cmp r0, #0 <== NOT EXECUTED 372e8: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED 372ec: 1affff95 bne 37148 <msdos_find_name_in_fat_file+0x178> <== NOT EXECUTED 372f0: eaffffc4 b 37208 <msdos_find_name_in_fat_file+0x238> <== NOT EXECUTED
/*
* The first entry must have the last long entry
* flag set.
*/
if ((*MSDOS_DIR_ENTRY_TYPE(entry) &
372f4: e3120040 tst r2, #64 ; 0x40 <== NOT EXECUTED 372f8: 0a000003 beq 3730c <msdos_find_name_in_fat_file+0x33c> <== NOT EXECUTED
* entry match the number we expect for this
* file name. Note we do not know the number of
* characters in the entry so this is check further
* on when the characters are checked.
*/
if (lfn_entries != (*MSDOS_DIR_ENTRY_TYPE(entry) &
372fc: e59d0038 ldr r0, [sp, #56] ; 0x38 <== NOT EXECUTED 37300: e202203f and r2, r2, #63 ; 0x3f <== NOT EXECUTED 37304: e1520000 cmp r2, r0 <== NOT EXECUTED 37308: 0a0000b2 beq 375d8 <msdos_find_name_in_fat_file+0x608> <== NOT EXECUTED
memcpy(name_dir_entry, entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
}
lfn_start.cln = FAT_FILE_SHORT_NAME;
3730c: e3a01000 mov r1, #0 <== NOT EXECUTED 37310: eaffff8f b 37154 <msdos_find_name_in_fat_file+0x184> <== NOT EXECUTED
* could be orphaned entries depending on the history
* of the disk.
*/
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
37314: e5d4200d ldrb r2, [r4, #13] <== NOT EXECUTED
* If the entry number or the check sum do not match
* forget this series of long directory entries. These
* could be orphaned entries depending on the history
* of the disk.
*/
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
37318: e1520003 cmp r2, r3 <== NOT EXECUTED
MSDOS_LAST_LONG_ENTRY_MASK)) ||
(lfn_checksum != *MSDOS_DIR_LFN_CHECKSUM(entry)))
3731c: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
* If the entry number or the check sum do not match
* forget this series of long directory entries. These
* could be orphaned entries depending on the history
* of the disk.
*/
if ((lfn_entry != (*MSDOS_DIR_ENTRY_TYPE(entry) &
37320: 1affffe3 bne 372b4 <msdos_find_name_in_fat_file+0x2e4> <== NOT EXECUTED
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
37324: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 37328: e2411001 sub r1, r1, #1 <== NOT EXECUTED
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
3732c: e0813081 add r3, r1, r1, lsl #1 <== NOT EXECUTED 37330: e0813103 add r3, r1, r3, lsl #2 <== NOT EXECUTED 37334: e58d3034 str r3, [sp, #52] ; 0x34 <== NOT EXECUTED 37338: e2842001 add r2, r4, #1 <== NOT EXECUTED 3733c: e58d203c str r2, [sp, #60] ; 0x3c <== NOT EXECUTED
#endif
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
37340: e58d1014 str r1, [sp, #20] <== NOT EXECUTED
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
37344: e59d2034 ldr r2, [sp, #52] ; 0x34 <== NOT EXECUTED 37348: e59d1040 ldr r1, [sp, #64] ; 0x40 <== NOT EXECUTED 3734c: e0811002 add r1, r1, r2 <== NOT EXECUTED
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
37350: e3a03001 mov r3, #1 <== NOT EXECUTED
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
37354: e58d1004 str r1, [sp, #4] <== NOT EXECUTED
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
37358: e58d3018 str r3, [sp, #24] <== NOT EXECUTED 3735c: e58d5044 str r5, [sp, #68] ; 0x44 <== NOT EXECUTED 37360: e58d0050 str r0, [sp, #80] ; 0x50 <== NOT EXECUTED 37364: e58db04c str fp, [sp, #76] ; 0x4c <== NOT EXECUTED 37368: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED 3736c: e1a0b007 mov fp, r7 <== NOT EXECUTED 37370: e58da03c str sl, [sp, #60] ; 0x3c <== NOT EXECUTED 37374: e3a03000 mov r3, #0 <== NOT EXECUTED 37378: e58d4048 str r4, [sp, #72] ; 0x48 <== NOT EXECUTED 3737c: e3a00001 mov r0, #1 <== NOT EXECUTED 37380: e1a05002 mov r5, r2 <== NOT EXECUTED 37384: e59d7084 ldr r7, [sp, #132] ; 0x84 <== NOT EXECUTED 37388: e59da004 ldr sl, [sp, #4] <== NOT EXECUTED 3738c: ea000006 b 373ac <msdos_find_name_in_fat_file+0x3dc> <== NOT EXECUTED
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
switch (i)
37390: e353000a cmp r3, #10 <== NOT EXECUTED 37394: 0a000011 beq 373e0 <msdos_find_name_in_fat_file+0x410> <== NOT EXECUTED
p = entry + 1;
#if MSDOS_FIND_PRINT
printf ("MSFS:[5] lfne:%i\n", lfn_entry);
#endif
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
37398: e350000c cmp r0, #12 <== NOT EXECUTED 3739c: ca000094 bgt 375f4 <msdos_find_name_in_fat_file+0x624> <== NOT EXECUTED
break;
case 10:
p += 4;
break;
default:
p += 2;
373a0: e2811002 add r1, r1, #2 <== NOT EXECUTED
lfn_start.cln = FAT_FILE_SHORT_NAME;
continue;
}
lfn_entry--;
o = lfn_entry * MSDOS_LFN_LEN_PER_ENTRY;
373a4: e2833001 add r3, r3, #1 <== NOT EXECUTED 373a8: e2800001 add r0, r0, #1 <== NOT EXECUTED
{
#if MSDOS_FIND_PRINT > 1
printf ("MSFS:[6] o:%i i:%i *p:%c(%02x) name[o + i]:%c(%02x)\n",
o, i, *p, *p, name[o + i], name[o + i]);
#endif
if (*p == '\0')
373ac: e5d12000 ldrb r2, [r1] <== NOT EXECUTED 373b0: e3520000 cmp r2, #0 <== NOT EXECUTED 373b4: 0a000131 beq 37880 <msdos_find_name_in_fat_file+0x8b0> <== NOT EXECUTED
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
373b8: e0834005 add r4, r3, r5 <== NOT EXECUTED 373bc: e1570004 cmp r7, r4 <== NOT EXECUTED 373c0: da0000a0 ble 37648 <msdos_find_name_in_fat_file+0x678> <== NOT EXECUTED 373c4: e7da4003 ldrb r4, [sl, r3] <== NOT EXECUTED 373c8: e1540002 cmp r4, r2 <== NOT EXECUTED 373cc: 1a00009d bne 37648 <msdos_find_name_in_fat_file+0x678> <== NOT EXECUTED
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
break;
}
switch (i)
373d0: e3530004 cmp r3, #4 <== NOT EXECUTED 373d4: 1affffed bne 37390 <msdos_find_name_in_fat_file+0x3c0> <== NOT EXECUTED
{
case 4:
p += 5;
373d8: e2811005 add r1, r1, #5 <== NOT EXECUTED
break;
373dc: eafffff0 b 373a4 <msdos_find_name_in_fat_file+0x3d4> <== NOT EXECUTED
case 10:
p += 4;
373e0: e2811004 add r1, r1, #4 <== NOT EXECUTED
break;
373e4: eaffffee b 373a4 <msdos_find_name_in_fat_file+0x3d4> <== NOT EXECUTED
#endif
/*
* If just looking and there is no more entries in the
* directory - return name-not-found
*/
if (!create_node)
373e8: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 373ec: e3520000 cmp r2, #0 <== NOT EXECUTED 373f0: 0a000135 beq 378cc <msdos_find_name_in_fat_file+0x8fc> <== NOT EXECUTED
* Lets go and write the directory entries. If we have not found
* any available space add the remaining number of entries to any that
* we may have already found that are just before this entry. If more
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
373f4: e35a0000 cmp sl, #0 <== NOT EXECUTED
{
empty_space_count +=
entries_per_block - (dir_entry / MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
373f8: 008772a9 addeq r7, r7, r9, lsr #5 <== NOT EXECUTED
* we may have already found that are just before this entry. If more
* are needed FAT_EOF is returned by the read and we extend the file.
*/
if (!empty_space_found)
{
empty_space_count +=
373fc: 004772a5 subeq r7, r7, r5, lsr #5 <== NOT EXECUTED
* data to place in each long file name entry. First set the short
* file name to the slot of the SFN entry. This will mean no clashes
* in this directory.
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
37400: e59d1088 ldr r1, [sp, #136] ; 0x88 <== NOT EXECUTED 37404: e3510002 cmp r1, #2 <== NOT EXECUTED 37408: 0a000137 beq 378ec <msdos_find_name_in_fat_file+0x91c> <== NOT EXECUTED
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
msdos_short_name_hex(MSDOS_DIR_NAME(name_dir_entry), slot);
}
if (lfn_entries)
3740c: e59d2038 ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED 37410: e3520000 cmp r2, #0 <== NOT EXECUTED 37414: 0a00000f beq 37458 <msdos_find_name_in_fat_file+0x488> <== NOT EXECUTED 37418: e3a03000 mov r3, #0 <== NOT EXECUTED 3741c: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 37420: e1a01003 mov r1, r3 <== NOT EXECUTED 37424: e1a02003 mov r2, r3 <== NOT EXECUTED 37428: e59dc090 ldr ip, [sp, #144] ; 0x90 <== NOT EXECUTED 3742c: ea000001 b 37438 <msdos_find_name_in_fat_file+0x468> <== NOT EXECUTED
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
lfn_checksum =
37430: e2111001 ands r1, r1, #1 <== NOT EXECUTED 37434: 13a01080 movne r1, #128 ; 0x80 <== NOT EXECUTED 37438: e7dc0003 ldrb r0, [ip, r3] <== NOT EXECUTED 3743c: e1a02b82 lsl r2, r2, #23 <== NOT EXECUTED 37440: e0811000 add r1, r1, r0 <== NOT EXECUTED
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
37444: e2833001 add r3, r3, #1 <== NOT EXECUTED
lfn_checksum =
37448: e0811c22 add r1, r1, r2, lsr #24 <== NOT EXECUTED
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
3744c: e353000b cmp r3, #11 <== NOT EXECUTED
lfn_checksum =
37450: e20120ff and r2, r1, #255 ; 0xff <== NOT EXECUTED
if (lfn_entries)
{
uint8_t* p = (uint8_t*) MSDOS_DIR_NAME(name_dir_entry);
int i;
for (i = 0; i < 11; i++, p++)
37454: 1afffff5 bne 37430 <msdos_find_name_in_fat_file+0x460> <== NOT EXECUTED
* empty_space_count is a count of empty entries in the currently
* read cluster so if 0 there is no space. Note, dir_offset will
* be at the next cluster so we can just make empty_space_offset
* that value.
*/
if (empty_space_count == 0)
37458: e3570000 cmp r7, #0 <== NOT EXECUTED 3745c: e58d2010 str r2, [sp, #16] <== NOT EXECUTED 37460: 01a06007 moveq r6, r7 <== NOT EXECUTED 37464: 03a03001 moveq r3, #1 <== NOT EXECUTED 37468: 0a00011b beq 378dc <msdos_find_name_in_fat_file+0x90c> <== NOT EXECUTED
}
/*
* Have we read past the empty block ? If so go back and read it again.
*/
if (dir_offset != empty_space_offset)
3746c: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED 37470: e1580003 cmp r8, r3 <== NOT EXECUTED 37474: 13a03001 movne r3, #1 <== NOT EXECUTED 37478: 0a000116 beq 378d8 <msdos_find_name_in_fat_file+0x908> <== NOT EXECUTED
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
3747c: e59dc038 ldr ip, [sp, #56] ; 0x38 <== NOT EXECUTED 37480: e35c0000 cmp ip, #0 <== NOT EXECUTED 37484: ba000116 blt 378e4 <msdos_find_name_in_fat_file+0x914> <== NOT EXECUTED
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
{
/* get current cluster number */
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
37488: e0000899 mul r0, r9, r8 <== NOT EXECUTED
*/
while (lfn_entry < (lfn_entries + 1))
{
int length = 0;
if (read_cluster)
3748c: e3530000 cmp r3, #0 <== NOT EXECUTED
read_cluster = true;
/*
* Handle the entry writes.
*/
lfn_start.cln = lfn_start.ofs = FAT_FILE_SHORT_NAME;
37490: e3e03000 mvn r3, #0 <== NOT EXECUTED 37494: e58d3054 str r3, [sp, #84] ; 0x54 <== NOT EXECUTED 37498: e58d3058 str r3, [sp, #88] ; 0x58 <== NOT EXECUTED
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
{
/* get current cluster number */
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
3749c: e58d001c str r0, [sp, #28] <== NOT EXECUTED 374a0: e3a05000 mov r5, #0 <== NOT EXECUTED
*/
while (lfn_entry < (lfn_entries + 1))
{
int length = 0;
if (read_cluster)
374a4: 1a0000bf bne 377a8 <msdos_find_name_in_fat_file+0x7d8> <== NOT EXECUTED
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.4] clear write: %d\n", ret);
#endif
if (ret == -1)
return ret;
else if (ret != bts2rd)
374a8: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 374ac: e58d1020 str r1, [sp, #32] <== NOT EXECUTED
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
374b0: e1590006 cmp r9, r6 <== NOT EXECUTED 374b4: 93a03000 movls r3, #0 <== NOT EXECUTED 374b8: 91a07005 movls r7, r5 <== NOT EXECUTED 374bc: 958d3018 strls r3, [sp, #24] <== NOT EXECUTED 374c0: 9a0000a1 bls 3774c <msdos_find_name_in_fat_file+0x77c> <== NOT EXECUTED
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
374c4: e59d3038 ldr r3, [sp, #56] ; 0x38 <== NOT EXECUTED
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
374c8: e59d2024 ldr r2, [sp, #36] ; 0x24 <== NOT EXECUTED
char* p;
const char* n;
int i;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
374cc: e2857001 add r7, r5, #1 <== NOT EXECUTED
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
374d0: e2833001 add r3, r3, #1 <== NOT EXECUTED 374d4: e1530007 cmp r3, r7 <== NOT EXECUTED
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
374d8: e5924098 ldr r4, [r2, #152] ; 0x98 <== NOT EXECUTED
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
374dc: 03a0c020 moveq ip, #32 <== NOT EXECUTED 374e0: e58d300c str r3, [sp, #12] <== NOT EXECUTED
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
374e4: e0844006 add r4, r4, r6 <== NOT EXECUTED
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
374e8: 01a05006 moveq r5, r6 <== NOT EXECUTED 374ec: 058dc018 streq ip, [sp, #24] <== NOT EXECUTED 374f0: 0a000073 beq 376c4 <msdos_find_name_in_fat_file+0x6f4> <== NOT EXECUTED
dir_pos->lname.ofs = lfn_start.ofs;
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
break;
374f4: e59d2038 ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED 374f8: e1e03005 mvn r3, r5 <== NOT EXECUTED 374fc: e0833002 add r3, r3, r2 <== NOT EXECUTED 37500: e20210ff and r1, r2, #255 ; 0xff <== NOT EXECUTED 37504: e3a00020 mov r0, #32 <== NOT EXECUTED 37508: e2811001 add r1, r1, #1 <== NOT EXECUTED 3750c: e0832083 add r2, r3, r3, lsl #1 <== NOT EXECUTED 37510: e59dc040 ldr ip, [sp, #64] ; 0x40 <== NOT EXECUTED 37514: e0833102 add r3, r3, r2, lsl #2 <== NOT EXECUTED 37518: e0671001 rsb r1, r7, r1 <== NOT EXECUTED 3751c: e1a05006 mov r5, r6 <== NOT EXECUTED 37520: e58d602c str r6, [sp, #44] ; 0x2c <== NOT EXECUTED 37524: e58d0018 str r0, [sp, #24] <== NOT EXECUTED 37528: e59d6024 ldr r6, [sp, #36] ; 0x24 <== NOT EXECUTED 3752c: e58d8014 str r8, [sp, #20] <== NOT EXECUTED 37530: e201a0ff and sl, r1, #255 ; 0xff <== NOT EXECUTED 37534: e08cb003 add fp, ip, r3 <== NOT EXECUTED 37538: e1a08000 mov r8, r0 <== NOT EXECUTED
* This is a long file name and we need to write
* a long file name entry. See if this is the
* first entry written and if so remember the
* the location of the long file name.
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
3753c: e59d3054 ldr r3, [sp, #84] ; 0x54 <== NOT EXECUTED 37540: e3730001 cmn r3, #1 <== NOT EXECUTED
{
lfn_start.cln = empty_space_offset;
37544: 059d1014 ldreq r1, [sp, #20] <== NOT EXECUTED
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
37548: e3a02020 mov r2, #32 <== NOT EXECUTED
* first entry written and if so remember the
* the location of the long file name.
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_start.cln = empty_space_offset;
3754c: 058d1054 streq r1, [sp, #84] ; 0x54 <== NOT EXECUTED
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
37550: e1a00004 mov r0, r4 <== NOT EXECUTED 37554: e3a01000 mov r1, #0 <== NOT EXECUTED
* the location of the long file name.
*/
if (lfn_start.cln == FAT_FILE_SHORT_NAME)
{
lfn_start.cln = empty_space_offset;
lfn_start.ofs = dir_entry;
37558: 058d5058 streq r5, [sp, #88] ; 0x58 <== NOT EXECUTED
}
/*
* Clear the entry before loading the data.
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
3755c: eb003bda bl 464cc <memset> <== NOT EXECUTED
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
37560: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 37564: e5c4200d strb r2, [r4, #13] <== NOT EXECUTED
p = entry + 1;
37568: e1a0200b mov r2, fp <== NOT EXECUTED
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
*p = *n;
3756c: e5d20000 ldrb r0, [r2] <== NOT EXECUTED
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
37570: e2841001 add r1, r4, #1 <== NOT EXECUTED
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
*p = *n;
37574: e5c10000 strb r0, [r1] <== NOT EXECUTED
if (*n != 0)
37578: e5d20000 ldrb r0, [r2] <== NOT EXECUTED
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
3757c: e3a03001 mov r3, #1 <== NOT EXECUTED
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
*p = *n;
if (*n != 0)
37580: e3500000 cmp r0, #0 <== NOT EXECUTED
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
37584: e2430001 sub r0, r3, #1 <== NOT EXECUTED
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
*p = *n;
if (*n != 0)
n++;
37588: 12822001 addne r2, r2, #1 <== NOT EXECUTED
switch (i)
3758c: e3500004 cmp r0, #4 <== NOT EXECUTED 37590: 0a00000d beq 375cc <msdos_find_name_in_fat_file+0x5fc> <== NOT EXECUTED 37594: e350000a cmp r0, #10 <== NOT EXECUTED 37598: 0a0000b0 beq 37860 <msdos_find_name_in_fat_file+0x890> <== NOT EXECUTED
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
3759c: e353000c cmp r3, #12 <== NOT EXECUTED 375a0: ca000030 bgt 37668 <msdos_find_name_in_fat_file+0x698> <== NOT EXECUTED
break;
case 10:
p += 4;
break;
default:
p += 2;
375a4: e2811002 add r1, r1, #2 <== NOT EXECUTED
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
375a8: e2833001 add r3, r3, #1 <== NOT EXECUTED
n = name + (lfn_entries - lfn_entry) * MSDOS_LFN_LEN_PER_ENTRY;
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
*p = *n;
375ac: e5d20000 ldrb r0, [r2] <== NOT EXECUTED 375b0: e5c10000 strb r0, [r1] <== NOT EXECUTED
if (*n != 0)
375b4: e5d20000 ldrb r0, [r2] <== NOT EXECUTED 375b8: e3500000 cmp r0, #0 <== NOT EXECUTED
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
375bc: e2430001 sub r0, r3, #1 <== NOT EXECUTED
for (i = 0; i < MSDOS_LFN_LEN_PER_ENTRY; i++)
{
*p = *n;
if (*n != 0)
n++;
375c0: 12822001 addne r2, r2, #1 <== NOT EXECUTED
switch (i)
375c4: e3500004 cmp r0, #4 <== NOT EXECUTED 375c8: 1afffff1 bne 37594 <msdos_find_name_in_fat_file+0x5c4> <== NOT EXECUTED
{
case 4:
p += 5;
375cc: e2811005 add r1, r1, #5 <== NOT EXECUTED
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
375d0: e2833001 add r3, r3, #1 <== NOT EXECUTED 375d4: eafffff4 b 375ac <msdos_find_name_in_fat_file+0x5dc> <== NOT EXECUTED
continue;
/*
* Get the checksum of the short entry.
*/
lfn_start.cln = dir_offset;
375d8: e58dc054 str ip, [sp, #84] ; 0x54 <== NOT EXECUTED
lfn_start.ofs = dir_entry;
375dc: e58d5058 str r5, [sp, #88] ; 0x58 <== NOT EXECUTED
lfn_entry = lfn_entries;
lfn_checksum = *MSDOS_DIR_LFN_CHECKSUM(entry);
375e0: e3a01000 mov r1, #0 <== NOT EXECUTED 375e4: e5d4300d ldrb r3, [r4, #13] <== NOT EXECUTED 375e8: e7db2005 ldrb r2, [fp, r5] <== NOT EXECUTED 375ec: e58d0014 str r0, [sp, #20] <== NOT EXECUTED 375f0: eaffff2b b 372a4 <msdos_find_name_in_fat_file+0x2d4> <== NOT EXECUTED 375f4: e1a0700b mov r7, fp <== NOT EXECUTED 375f8: e59d5044 ldr r5, [sp, #68] ; 0x44 <== NOT EXECUTED 375fc: e59d4048 ldr r4, [sp, #72] ; 0x48 <== NOT EXECUTED 37600: e59da03c ldr sl, [sp, #60] ; 0x3c <== NOT EXECUTED 37604: e59db04c ldr fp, [sp, #76] ; 0x4c <== NOT EXECUTED
p += 2;
break;
}
}
lfn_matched = ((lfn_entry == 0) &&
37608: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 3760c: e3530000 cmp r3, #0 <== NOT EXECUTED 37610: 1affff3d bne 3730c <msdos_find_name_in_fat_file+0x33c> <== NOT EXECUTED
* RC_OK on success, or error code if error occured (errno set * appropriately) * */ #define MSDOS_FIND_PRINT 0 int msdos_find_name_in_fat_file(
37614: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED 37618: e2911001 adds r1, r1, #1 <== NOT EXECUTED 3761c: 13a01001 movne r1, #1 <== NOT EXECUTED 37620: eafffecb b 37154 <msdos_find_name_in_fat_file+0x184> <== NOT EXECUTED
lfn_entries = 0;
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
37624: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED 37628: e3530000 cmp r3, #0 <== NOT EXECUTED 3762c: 1afffe8c bne 37064 <msdos_find_name_in_fat_file+0x94> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
37630: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 37634: e5d1300a ldrb r3, [r1, #10] <== NOT EXECUTED 37638: e3130003 tst r3, #3 <== NOT EXECUTED
bts2rd = fat_fd->fat_file_size;
3763c: 15909018 ldrne r9, [r0, #24] <== NOT EXECUTED
else
lfn_entries =
((name_len - 1) + MSDOS_LFN_LEN_PER_ENTRY) / MSDOS_LFN_LEN_PER_ENTRY;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
37640: 1afffe89 bne 3706c <msdos_find_name_in_fat_file+0x9c> <== NOT EXECUTED 37644: eafffe86 b 37064 <msdos_find_name_in_fat_file+0x94> <== NOT EXECUTED
break;
}
if (((o + i) >= name_len) || (*p != name[o + i]))
{
lfn_start.cln = FAT_FILE_SHORT_NAME;
37648: e3e02000 mvn r2, #0 <== NOT EXECUTED 3764c: e1a0700b mov r7, fp <== NOT EXECUTED 37650: e59d5044 ldr r5, [sp, #68] ; 0x44 <== NOT EXECUTED 37654: e59d4048 ldr r4, [sp, #72] ; 0x48 <== NOT EXECUTED 37658: e59da03c ldr sl, [sp, #60] ; 0x3c <== NOT EXECUTED 3765c: e59db04c ldr fp, [sp, #76] ; 0x4c <== NOT EXECUTED 37660: e58d2054 str r2, [sp, #84] ; 0x54 <== NOT EXECUTED
break;
37664: eaffffe7 b 37608 <msdos_find_name_in_fat_file+0x638> <== NOT EXECUTED
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
37668: e3570001 cmp r7, #1 <== NOT EXECUTED
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
3766c: 038a3040 orreq r3, sl, #64 ; 0x40 <== NOT EXECUTED
p += 2;
break;
}
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
37670: e5c4a000 strb sl, [r4] <== NOT EXECUTED
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
37674: 05c43000 strbeq r3, [r4] <== NOT EXECUTED
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
37678: e5d4300b ldrb r3, [r4, #11] <== NOT EXECUTED
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
3767c: e2855020 add r5, r5, #32 <== NOT EXECUTED
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
37680: e383300f orr r3, r3, #15 <== NOT EXECUTED
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
37684: e1590005 cmp r9, r5 <== NOT EXECUTED
}
*MSDOS_DIR_ENTRY_TYPE(entry) = (lfn_entries - lfn_entry) + 1;
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
37688: e5c4300b strb r3, [r4, #11] <== NOT EXECUTED
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
3768c: 9a000076 bls 3786c <msdos_find_name_in_fat_file+0x89c> <== NOT EXECUTED
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
37690: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED
char* p;
const char* n;
int i;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
37694: e2877001 add r7, r7, #1 <== NOT EXECUTED
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
37698: e5964098 ldr r4, [r6, #152] ; 0x98 <== NOT EXECUTED
char* p;
const char* n;
int i;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
lfn_entry++;
3769c: e24aa001 sub sl, sl, #1 <== NOT EXECUTED
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
376a0: e1570000 cmp r7, r0 <== NOT EXECUTED
for (dir_entry = empty_space_entry;
dir_entry < bts2rd;
dir_entry += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + dir_entry;
376a4: e0844005 add r4, r4, r5 <== NOT EXECUTED
char* p;
const char* n;
int i;
length += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
376a8: e2888020 add r8, r8, #32 <== NOT EXECUTED
lfn_entry++;
376ac: e20aa0ff and sl, sl, #255 ; 0xff <== NOT EXECUTED 376b0: e24bb00d sub fp, fp, #13 <== NOT EXECUTED
length, lfn_entry);
#endif
/*
* Time to write the short file name entry.
*/
if (lfn_entry == (lfn_entries + 1))
376b4: 1affffa0 bne 3753c <msdos_find_name_in_fat_file+0x56c> <== NOT EXECUTED 376b8: e58d8018 str r8, [sp, #24] <== NOT EXECUTED 376bc: e59d602c ldr r6, [sp, #44] ; 0x2c <== NOT EXECUTED 376c0: e59d8014 ldr r8, [sp, #20] <== NOT EXECUTED
{
/* get current cluster number */
int rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
376c4: e59dc08c ldr ip, [sp, #140] ; 0x8c <== NOT EXECUTED 376c8: e59d0030 ldr r0, [sp, #48] ; 0x30 <== NOT EXECUTED 376cc: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED 376d0: e3a02001 mov r2, #1 <== NOT EXECUTED 376d4: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 376d8: e58dc000 str ip, [sp] <== NOT EXECUTED 376dc: ebffb710 bl 25324 <fat_file_ioctl> <== NOT EXECUTED
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
376e0: e3500000 cmp r0, #0 <== NOT EXECUTED 376e4: 1afffee8 bne 3728c <msdos_find_name_in_fat_file+0x2bc> <== NOT EXECUTED
return rc;
dir_pos->sname.ofs = dir_entry;
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
376e8: e59d3054 ldr r3, [sp, #84] ; 0x54 <== NOT EXECUTED
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
376ec: e59d008c ldr r0, [sp, #140] ; 0x8c <== NOT EXECUTED
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
376f0: e3730001 cmn r3, #1 <== NOT EXECUTED
empty_space_offset * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = dir_entry;
376f4: e5805004 str r5, [r0, #4] <== NOT EXECUTED
if (lfn_start.cln != FAT_FILE_SHORT_NAME)
376f8: 0a000009 beq 37724 <msdos_find_name_in_fat_file+0x754> <== NOT EXECUTED
{
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM,
376fc: e28dc054 add ip, sp, #84 ; 0x54 <== NOT EXECUTED 37700: e0030399 mul r3, r9, r3 <== NOT EXECUTED 37704: e59d0030 ldr r0, [sp, #48] ; 0x30 <== NOT EXECUTED 37708: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED 3770c: e3a02001 mov r2, #1 <== NOT EXECUTED 37710: e58dc000 str ip, [sp] <== NOT EXECUTED 37714: ebffb702 bl 25324 <fat_file_ioctl> <== NOT EXECUTED
lfn_start.cln * bts2rd,
&lfn_start.cln);
if (rc != RC_OK)
37718: e3500000 cmp r0, #0 <== NOT EXECUTED 3771c: 1afffeda bne 3728c <msdos_find_name_in_fat_file+0x2bc> <== NOT EXECUTED 37720: e59d3054 ldr r3, [sp, #84] ; 0x54 <== NOT EXECUTED
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
37724: e59d108c ldr r1, [sp, #140] ; 0x8c <== NOT EXECUTED 37728: e5813008 str r3, [r1, #8] <== NOT EXECUTED
dir_pos->lname.ofs = lfn_start.ofs;
3772c: e59d3058 ldr r3, [sp, #88] ; 0x58 <== NOT EXECUTED
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
37730: e1a00004 mov r0, r4 <== NOT EXECUTED
if (rc != RC_OK)
return rc;
}
dir_pos->lname.cln = lfn_start.cln;
dir_pos->lname.ofs = lfn_start.ofs;
37734: e581300c str r3, [r1, #12] <== NOT EXECUTED
/* write new node entry */
memcpy (entry, (uint8_t *) name_dir_entry,
37738: e3a02020 mov r2, #32 <== NOT EXECUTED 3773c: e59d1090 ldr r1, [sp, #144] ; 0x90 <== NOT EXECUTED 37740: eb003ada bl 462b0 <memcpy> <== NOT EXECUTED 37744: e59d700c ldr r7, [sp, #12] <== NOT EXECUTED 37748: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
if (lfn_entry == 1)
*MSDOS_DIR_ENTRY_TYPE(entry) |= MSDOS_LAST_LONG_ENTRY;
*MSDOS_DIR_ATTR(entry) |= MSDOS_ATTR_LFN;
}
ret = fat_file_write(mt_entry, fat_fd,
3774c: e28d0020 add r0, sp, #32 <== NOT EXECUTED
37750: e8901001 ldm r0, {r0, ip} <== NOT EXECUTED
37754: e59c1098 ldr r1, [ip, #152] ; 0x98 <== NOT EXECUTED
37758: e0802006 add r2, r0, r6 <== NOT EXECUTED
3775c: e0816006 add r6, r1, r6 <== NOT EXECUTED
37760: e59d0030 ldr r0, [sp, #48] ; 0x30 <== NOT EXECUTED
37764: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED
37768: e58d6000 str r6, [sp] <== NOT EXECUTED
3776c: ebffb7e0 bl 256f4 <fat_file_write> <== NOT EXECUTED
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
37770: e3700001 cmn r0, #1 <== NOT EXECUTED 37774: 0a00007a beq 37964 <msdos_find_name_in_fat_file+0x994> <== NOT EXECUTED
return ret;
else if (ret != length)
37778: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED 3777c: e1510000 cmp r1, r0 <== NOT EXECUTED 37780: 1a000031 bne 3784c <msdos_find_name_in_fat_file+0x87c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
37784: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
37788: e59d2038 ldr r2, [sp, #56] ; 0x38 <== NOT EXECUTED
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
3778c: e0833009 add r3, r3, r9 <== NOT EXECUTED
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
37790: e1520007 cmp r2, r7 <== NOT EXECUTED
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
37794: e58d301c str r3, [sp, #28] <== NOT EXECUTED
empty_space_offset++;
37798: a2888001 addge r8, r8, #1 <== NOT EXECUTED 3779c: a1a05007 movge r5, r7 <== NOT EXECUTED 377a0: a3a06000 movge r6, #0 <== NOT EXECUTED
#endif
/*
* The one more is the short entry.
*/
while (lfn_entry < (lfn_entries + 1))
377a4: ba00004e blt 378e4 <msdos_find_name_in_fat_file+0x914> <== NOT EXECUTED
{
uint32_t new_length;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.1] eso:%li\n", empty_space_offset);
#endif
ret = fat_file_read(mt_entry, fat_fd,
377a8: e59d1024 ldr r1, [sp, #36] ; 0x24 <== NOT EXECUTED 377ac: e591c098 ldr ip, [r1, #152] ; 0x98 <== NOT EXECUTED 377b0: e59d0030 ldr r0, [sp, #48] ; 0x30 <== NOT EXECUTED 377b4: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED 377b8: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 377bc: e1a03009 mov r3, r9 <== NOT EXECUTED 377c0: e58dc000 str ip, [sp] <== NOT EXECUTED 377c4: ebffb860 bl 2594c <fat_file_read> <== NOT EXECUTED
(empty_space_offset * bts2rd), bts2rd,
fs_info->cl_buf);
if (ret != bts2rd)
377c8: e1500009 cmp r0, r9 <== NOT EXECUTED 377cc: 0affff35 beq 374a8 <msdos_find_name_in_fat_file+0x4d8> <== NOT EXECUTED
{
if (ret != FAT_EOF)
377d0: e3500000 cmp r0, #0 <== NOT EXECUTED 377d4: 1a00001c bne 3784c <msdos_find_name_in_fat_file+0x87c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.2] extending file:%li\n", empty_space_offset);
#endif
ret = fat_file_extend (mt_entry, fat_fd, empty_space_offset * bts2rd,
377d8: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED 377dc: e59d0030 ldr r0, [sp, #48] ; 0x30 <== NOT EXECUTED 377e0: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 377e4: e28d305c add r3, sp, #92 ; 0x5c <== NOT EXECUTED 377e8: ebffb749 bl 25514 <fat_file_extend> <== NOT EXECUTED
&new_length);
if (ret != RC_OK)
377ec: e2501000 subs r1, r0, #0 <== NOT EXECUTED 377f0: 11a00001 movne r0, r1 <== NOT EXECUTED 377f4: 1afffea4 bne 3728c <msdos_find_name_in_fat_file+0x2bc> <== NOT EXECUTED
return ret;
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.3] extended: %d <-> %d\n", new_length, empty_space_offset * bts2rd);
#endif
if (new_length != (empty_space_offset * bts2rd))
377f8: e59d205c ldr r2, [sp, #92] ; 0x5c <== NOT EXECUTED 377fc: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 37800: e1520003 cmp r2, r3 <== NOT EXECUTED 37804: e58d2020 str r2, [sp, #32] <== NOT EXECUTED 37808: 1a00000f bne 3784c <msdos_find_name_in_fat_file+0x87c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
memset(fs_info->cl_buf, 0, bts2rd);
3780c: e59dc024 ldr ip, [sp, #36] ; 0x24 <== NOT EXECUTED 37810: e1a02009 mov r2, r9 <== NOT EXECUTED 37814: e59c0098 ldr r0, [ip, #152] ; 0x98 <== NOT EXECUTED 37818: eb003b2b bl 464cc <memset> <== NOT EXECUTED
ret = fat_file_write(mt_entry, fat_fd,
3781c: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED 37820: e590c098 ldr ip, [r0, #152] ; 0x98 <== NOT EXECUTED 37824: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED 37828: e59d0030 ldr r0, [sp, #48] ; 0x30 <== NOT EXECUTED 3782c: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 37830: e1a03009 mov r3, r9 <== NOT EXECUTED 37834: e58dc000 str ip, [sp] <== NOT EXECUTED 37838: ebffb7ad bl 256f4 <fat_file_write> <== NOT EXECUTED
empty_space_offset * bts2rd,
bts2rd, fs_info->cl_buf);
#if MSDOS_FIND_PRINT
printf ("MSFS:[9.4] clear write: %d\n", ret);
#endif
if (ret == -1)
3783c: e3700001 cmn r0, #1 <== NOT EXECUTED 37840: 0a000047 beq 37964 <msdos_find_name_in_fat_file+0x994> <== NOT EXECUTED
return ret;
else if (ret != bts2rd)
37844: e1500009 cmp r0, r9 <== NOT EXECUTED 37848: 0affff18 beq 374b0 <msdos_find_name_in_fat_file+0x4e0> <== NOT EXECUTED
(empty_space_offset * bts2rd) + empty_space_entry,
length, fs_info->cl_buf + empty_space_entry);
if (ret == -1)
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
3784c: eb002de7 bl 42ff0 <__errno> <== NOT EXECUTED 37850: e3a03005 mov r3, #5 <== NOT EXECUTED 37854: e5803000 str r3, [r0] <== NOT EXECUTED 37858: e3e00000 mvn r0, #0 <== NOT EXECUTED 3785c: eafffe8a b 3728c <msdos_find_name_in_fat_file+0x2bc> <== NOT EXECUTED
{
case 4:
p += 5;
break;
case 10:
p += 4;
37860: e2811004 add r1, r1, #4 <== NOT EXECUTED
*/
memset (entry, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
*MSDOS_DIR_LFN_CHECKSUM(entry) = lfn_checksum;
p = entry + 1;
37864: e2833001 add r3, r3, #1 <== NOT EXECUTED 37868: eaffff4f b 375ac <msdos_find_name_in_fat_file+0x5dc> <== NOT EXECUTED 3786c: e58d8018 str r8, [sp, #24] <== NOT EXECUTED 37870: e59d602c ldr r6, [sp, #44] ; 0x2c <== NOT EXECUTED 37874: e59d8014 ldr r8, [sp, #20] <== NOT EXECUTED
#if MSDOS_FIND_PRINT
printf ("MSFS:[10] eso:%li\n", empty_space_offset);
#endif
for (dir_entry = empty_space_entry;
37878: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 3787c: eaffffb2 b 3774c <msdos_find_name_in_fat_file+0x77c> <== NOT EXECUTED 37880: e59d0050 ldr r0, [sp, #80] ; 0x50 <== NOT EXECUTED
/*
* If this is the first entry, ie the last part of the
* long file name and the length does not match then
* the file names do not match.
*/
if (((lfn_entry + 1) == lfn_entries) &&
37884: e59d1038 ldr r1, [sp, #56] ; 0x38 <== NOT EXECUTED 37888: e1510000 cmp r1, r0 <== NOT EXECUTED 3788c: e1a0700b mov r7, fp <== NOT EXECUTED 37890: e59d5044 ldr r5, [sp, #68] ; 0x44 <== NOT EXECUTED 37894: e59d4048 ldr r4, [sp, #72] ; 0x48 <== NOT EXECUTED 37898: e59da03c ldr sl, [sp, #60] ; 0x3c <== NOT EXECUTED 3789c: e59db04c ldr fp, [sp, #76] ; 0x4c <== NOT EXECUTED 378a0: 1affff58 bne 37608 <msdos_find_name_in_fat_file+0x638> <== NOT EXECUTED 378a4: e59d2034 ldr r2, [sp, #52] ; 0x34 <== NOT EXECUTED 378a8: e59d0084 ldr r0, [sp, #132] ; 0x84 <== NOT EXECUTED 378ac: e0833002 add r3, r3, r2 <== NOT EXECUTED 378b0: e1530000 cmp r3, r0 <== NOT EXECUTED
((o + i) != name_len))
lfn_start.cln = FAT_FILE_SHORT_NAME;
378b4: 13e01000 mvnne r1, #0 <== NOT EXECUTED 378b8: 158d1054 strne r1, [sp, #84] ; 0x54 <== NOT EXECUTED 378bc: eaffff51 b 37608 <msdos_find_name_in_fat_file+0x638> <== NOT EXECUTED
}
/*
* If we are not to create the entry return a not found error.
*/
if (!create_node)
378c0: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED 378c4: e3500000 cmp r0, #0 <== NOT EXECUTED 378c8: 1afffecc bne 37400 <msdos_find_name_in_fat_file+0x430> <== NOT EXECUTED
if (ret == -1)
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
empty_space_offset++;
378cc: e3a00c7d mov r0, #32000 ; 0x7d00 <== NOT EXECUTED 378d0: e2800001 add r0, r0, #1 <== NOT EXECUTED 378d4: eafffe6c b 3728c <msdos_find_name_in_fat_file+0x2bc> <== NOT EXECUTED
}
/*
* Have we read past the empty block ? If so go back and read it again.
*/
if (dir_offset != empty_space_offset)
378d8: e3a03000 mov r3, #0 <== NOT EXECUTED 378dc: e59d802c ldr r8, [sp, #44] ; 0x2c <== NOT EXECUTED 378e0: eafffee5 b 3747c <msdos_find_name_in_fat_file+0x4ac> <== NOT EXECUTED
if (ret == -1)
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
empty_space_offset++;
378e4: e3a00000 mov r0, #0 <== NOT EXECUTED 378e8: eafffe67 b 3728c <msdos_find_name_in_fat_file+0x2bc> <== NOT EXECUTED
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
378ec: e0226899 mla r2, r9, r8, r6 <== NOT EXECUTED 378f0: e59dc038 ldr ip, [sp, #56] ; 0x38 <== NOT EXECUTED 378f4: e28c3001 add r3, ip, #1 <== NOT EXECUTED
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 3; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '~';
378f8: e59dc090 ldr ip, [sp, #144] ; 0x90 <== NOT EXECUTED
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
378fc: e08302a2 add r0, r3, r2, lsr #5 <== NOT EXECUTED
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 3; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '~';
37900: e281107c add r1, r1, #124 ; 0x7c <== NOT EXECUTED
*/
lfn_checksum = 0;
if (name_type == MSDOS_NAME_LONG)
{
int slot = (((empty_space_offset * bts2rd) + empty_space_entry) /
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE) + lfn_entries + 1;
37904: e3a03000 mov r3, #0 <== NOT EXECUTED
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 3; i++, c++)
if ((*c == ' ') || (*c == '.'))
37908: e7dc2003 ldrb r2, [ip, r3] <== NOT EXECUTED 3790c: e3520020 cmp r2, #32 <== NOT EXECUTED 37910: 1352002e cmpne r2, #46 ; 0x2e <== NOT EXECUTED
*c = '~';
37914: 07cc1003 strbeq r1, [ip, r3] <== NOT EXECUTED
msdos_short_name_hex(char* sfn, int num)
{
static const char* hex = "0123456789ABCDEF";
char* c = MSDOS_DIR_NAME(sfn);
int i;
for (i = 0; i < 3; i++, c++)
37918: e2833001 add r3, r3, #1 <== NOT EXECUTED 3791c: e3530003 cmp r3, #3 <== NOT EXECUTED 37920: 1afffff8 bne 37908 <msdos_find_name_in_fat_file+0x938> <== NOT EXECUTED
if ((*c == ' ') || (*c == '.'))
*c = '~';
*c++ = '~';
37924: e59d1090 ldr r1, [sp, #144] ; 0x90 <== NOT EXECUTED 37928: e283307b add r3, r3, #123 ; 0x7b <== NOT EXECUTED 3792c: e5c13003 strb r3, [r1, #3] <== NOT EXECUTED 37930: e59f3068 ldr r3, [pc, #104] ; 379a0 <msdos_find_name_in_fat_file+0x9d0><== NOT EXECUTED 37934: e59d1090 ldr r1, [sp, #144] ; 0x90 <== NOT EXECUTED 37938: e593c048 ldr ip, [r3, #72] ; 0x48 <== NOT EXECUTED 3793c: e3a0300c mov r3, #12 <== NOT EXECUTED
for (i = 0; i < 4; i++, c++)
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
37940: e1a02350 asr r2, r0, r3 <== NOT EXECUTED 37944: e202200f and r2, r2, #15 <== NOT EXECUTED 37948: e7dc2002 ldrb r2, [ip, r2] <== NOT EXECUTED 3794c: e2433004 sub r3, r3, #4 <== NOT EXECUTED
int i;
for (i = 0; i < 3; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '~';
*c++ = '~';
for (i = 0; i < 4; i++, c++)
37950: e3730004 cmn r3, #4 <== NOT EXECUTED
*c = hex[(num >> ((3 - i) * 4)) & 0xf];
37954: e5c12004 strb r2, [r1, #4] <== NOT EXECUTED 37958: e2811001 add r1, r1, #1 <== NOT EXECUTED
int i;
for (i = 0; i < 3; i++, c++)
if ((*c == ' ') || (*c == '.'))
*c = '~';
*c++ = '~';
for (i = 0; i < 4; i++, c++)
3795c: 1afffff7 bne 37940 <msdos_find_name_in_fat_file+0x970> <== NOT EXECUTED 37960: eafffea9 b 3740c <msdos_find_name_in_fat_file+0x43c> <== NOT EXECUTED
if (ret == -1)
return ret;
else if (ret != length)
rtems_set_errno_and_return_minus_one(EIO);
empty_space_offset++;
37964: e3e00000 mvn r0, #0 <== NOT EXECUTED 37968: eafffe47 b 3728c <msdos_find_name_in_fat_file+0x2bc> <== NOT EXECUTED
#endif
if (ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
rtems_set_errno_and_return_minus_one(EIO);
assert(ret == bts2rd);
3796c: e3a01d11 mov r1, #1088 ; 0x440 <== NOT EXECUTED 37970: e2811009 add r1, r1, #9 <== NOT EXECUTED 37974: e59f0028 ldr r0, [pc, #40] ; 379a4 <msdos_find_name_in_fat_file+0x9d4><== NOT EXECUTED 37978: e59f2028 ldr r2, [pc, #40] ; 379a8 <msdos_find_name_in_fat_file+0x9d8><== NOT EXECUTED 3797c: e59f3028 ldr r3, [pc, #40] ; 379ac <msdos_find_name_in_fat_file+0x9dc><== NOT EXECUTED 37980: ebffc3e7 bl 28924 <__assert_func> <== NOT EXECUTED
uint32_t empty_space_count = 0;
bool empty_space_found = false;
uint32_t entries_per_block;
bool read_cluster = false;
assert(name_len > 0);
37984: e3a01e41 mov r1, #1040 ; 0x410 <== NOT EXECUTED 37988: e2811009 add r1, r1, #9 <== NOT EXECUTED 3798c: e59f0010 ldr r0, [pc, #16] ; 379a4 <msdos_find_name_in_fat_file+0x9d4><== NOT EXECUTED 37990: e59f2010 ldr r2, [pc, #16] ; 379a8 <msdos_find_name_in_fat_file+0x9d8><== NOT EXECUTED 37994: e59f3014 ldr r3, [pc, #20] ; 379b0 <msdos_find_name_in_fat_file+0x9e0><== NOT EXECUTED 37998: ebffc3e1 bl 28924 <__assert_func> <== NOT EXECUTED
00036e68 <msdos_find_node_by_cluster_num_in_fat_file>:
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
36e68: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
36e6c: e1a08001 mov r8, r1 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
36e70: e5911020 ldr r1, [r1, #32] <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
36e74: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
36e78: e3510001 cmp r1, #1 <== NOT EXECUTED
fat_file_fd_t *fat_fd,
uint32_t cl4find,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
36e7c: e1a0b000 mov fp, r0 <== NOT EXECUTED 36e80: e1a07002 mov r7, r2 <== NOT EXECUTED 36e84: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
int rc = RC_OK;
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
36e88: e590a034 ldr sl, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
36e8c: 0a000026 beq 36f2c <msdos_find_node_by_cluster_num_in_fat_file+0xc4><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
36e90: e1da60b6 ldrh r6, [sl, #6] <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
36e94: e59ac098 ldr ip, [sl, #152] ; 0x98 <== NOT EXECUTED 36e98: e3a09000 mov r9, #0 <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
36e9c: e1a0000b mov r0, fp <== NOT EXECUTED 36ea0: e1a01008 mov r1, r8 <== NOT EXECUTED 36ea4: e1a02009 mov r2, r9 <== NOT EXECUTED 36ea8: e1a03006 mov r3, r6 <== NOT EXECUTED 36eac: e58dc000 str ip, [sp] <== NOT EXECUTED 36eb0: ebffbaa5 bl 2594c <fat_file_read> <== NOT EXECUTED 36eb4: e3500000 cmp r0, #0 <== NOT EXECUTED 36eb8: 0a000016 beq 36f18 <msdos_find_node_by_cluster_num_in_fat_file+0xb0><== NOT EXECUTED
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
36ebc: e350001f cmp r0, #31 <== NOT EXECUTED 36ec0: da000034 ble 36f98 <msdos_find_node_by_cluster_num_in_fat_file+0x130><== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
36ec4: e1500006 cmp r0, r6 <== NOT EXECUTED 36ec8: 1a000037 bne 36fac <msdos_find_node_by_cluster_num_in_fat_file+0x144><== NOT EXECUTED 36ecc: e59ac098 ldr ip, [sl, #152] ; 0x98 <== NOT EXECUTED 36ed0: e3a04000 mov r4, #0 <== NOT EXECUTED 36ed4: e1a0500c mov r5, ip <== NOT EXECUTED
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
{
char* entry = (char*) fs_info->cl_buf + i;
/* if this and all rest entries are empty - return not-found */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
36ed8: e7dc3004 ldrb r3, [ip, r4] <== NOT EXECUTED 36edc: e3530000 cmp r3, #0 <== NOT EXECUTED 36ee0: 0a00000c beq 36f18 <msdos_find_node_by_cluster_num_in_fat_file+0xb0><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_AND_REST_EMPTY)
return MSDOS_NAME_NOT_FOUND_ERR;
/* if this entry is empty - skip it */
if ((*MSDOS_DIR_ENTRY_TYPE(entry)) ==
36ee4: e35300e5 cmp r3, #229 ; 0xe5 <== NOT EXECUTED 36ee8: 0a000004 beq 36f00 <msdos_find_node_by_cluster_num_in_fat_file+0x98><== NOT EXECUTED
MSDOS_THIS_DIR_ENTRY_EMPTY)
continue;
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
36eec: e1d521b4 ldrh r2, [r5, #20] <== NOT EXECUTED 36ef0: e1d531ba ldrh r3, [r5, #26] <== NOT EXECUTED 36ef4: e1833802 orr r3, r3, r2, lsl #16 <== NOT EXECUTED 36ef8: e1530007 cmp r3, r7 <== NOT EXECUTED 36efc: 0a000012 beq 36f4c <msdos_find_node_by_cluster_num_in_fat_file+0xe4><== NOT EXECUTED
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
assert(ret == bts2rd);
for (i = 0; i < bts2rd; i += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE)
36f00: e2844020 add r4, r4, #32 <== NOT EXECUTED 36f04: e1560004 cmp r6, r4 <== NOT EXECUTED 36f08: e2855020 add r5, r5, #32 <== NOT EXECUTED 36f0c: 8afffff1 bhi 36ed8 <msdos_find_node_by_cluster_num_in_fat_file+0x70><== NOT EXECUTED 36f10: e0899006 add r9, r9, r6 <== NOT EXECUTED 36f14: eaffffe0 b 36e9c <msdos_find_node_by_cluster_num_in_fat_file+0x34><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
bts2rd = fat_fd->fat_file_size;
else
bts2rd = fs_info->fat.vol.bpc;
while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
36f18: e3a06c7d mov r6, #32000 ; 0x7d00 <== NOT EXECUTED 36f1c: e2866001 add r6, r6, #1 <== NOT EXECUTED
}
}
j++;
}
return MSDOS_NAME_NOT_FOUND_ERR;
}
36f20: e1a00006 mov r0, r6 <== NOT EXECUTED
36f24: e28dd008 add sp, sp, #8 <== NOT EXECUTED
36f28: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
36f2c: e5983024 ldr r3, [r8, #36] ; 0x24 <== NOT EXECUTED 36f30: e3530000 cmp r3, #0 <== NOT EXECUTED 36f34: 1affffd5 bne 36e90 <msdos_find_node_by_cluster_num_in_fat_file+0x28><== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
36f38: e5da300a ldrb r3, [sl, #10] <== NOT EXECUTED 36f3c: e3130003 tst r3, #3 <== NOT EXECUTED 36f40: 0affffd2 beq 36e90 <msdos_find_node_by_cluster_num_in_fat_file+0x28><== NOT EXECUTED
bts2rd = fat_fd->fat_file_size;
36f44: e5986018 ldr r6, [r8, #24] <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t bts2rd = 0;
uint32_t i = 0, j = 0;
if (FAT_FD_OF_ROOT_DIR(fat_fd) &&
36f48: eaffffd1 b 36e94 <msdos_find_node_by_cluster_num_in_fat_file+0x2c><== NOT EXECUTED
/* if get a non-empty entry - compare clusters num */
if (MSDOS_EXTRACT_CLUSTER_NUM(entry) == cl4find)
{
/* on success fill aux structure and copy all 32 bytes */
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
36f4c: e59dc004 ldr ip, [sp, #4] <== NOT EXECUTED 36f50: e1a0000b mov r0, fp <== NOT EXECUTED 36f54: e1a01008 mov r1, r8 <== NOT EXECUTED 36f58: e1a03009 mov r3, r9 <== NOT EXECUTED 36f5c: e3a02001 mov r2, #1 <== NOT EXECUTED 36f60: e58dc000 str ip, [sp] <== NOT EXECUTED 36f64: ebffb8ee bl 25324 <fat_file_ioctl> <== NOT EXECUTED
&dir_pos->sname.cln);
if (rc != RC_OK)
36f68: e2506000 subs r6, r0, #0 <== NOT EXECUTED 36f6c: 1affffeb bne 36f20 <msdos_find_node_by_cluster_num_in_fat_file+0xb8><== NOT EXECUTED
return rc;
dir_pos->sname.ofs = i;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
36f70: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = i;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
36f74: e3e03000 mvn r3, #0 <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
36f78: e582300c str r3, [r2, #12] <== NOT EXECUTED
rc = fat_file_ioctl(mt_entry, fat_fd, F_CLU_NUM, j * bts2rd,
&dir_pos->sname.cln);
if (rc != RC_OK)
return rc;
dir_pos->sname.ofs = i;
36f7c: e5824004 str r4, [r2, #4] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
36f80: e5823008 str r3, [r2, #8] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
memcpy(dir_entry, entry,
36f84: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED 36f88: e1a01005 mov r1, r5 <== NOT EXECUTED 36f8c: e3a02020 mov r2, #32 <== NOT EXECUTED 36f90: eb003cc6 bl 462b0 <memcpy> <== NOT EXECUTED
MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
return RC_OK;
36f94: eaffffe1 b 36f20 <msdos_find_node_by_cluster_num_in_fat_file+0xb8><== NOT EXECUTED
while ((ret = fat_file_read(mt_entry, fat_fd, j * bts2rd, bts2rd,
fs_info->cl_buf)) != FAT_EOF)
{
if ( ret < MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE )
rtems_set_errno_and_return_minus_one( EIO );
36f98: eb003014 bl 42ff0 <__errno> <== NOT EXECUTED 36f9c: e3a03005 mov r3, #5 <== NOT EXECUTED 36fa0: e5803000 str r3, [r0] <== NOT EXECUTED 36fa4: e3e06000 mvn r6, #0 <== NOT EXECUTED 36fa8: eaffffdc b 36f20 <msdos_find_node_by_cluster_num_in_fat_file+0xb8><== NOT EXECUTED
assert(ret == bts2rd);
36fac: e3a01e69 mov r1, #1680 ; 0x690 <== NOT EXECUTED 36fb0: e2811005 add r1, r1, #5 <== NOT EXECUTED 36fb4: e59f0008 ldr r0, [pc, #8] ; 36fc4 <msdos_find_node_by_cluster_num_in_fat_file+0x15c><== NOT EXECUTED 36fb8: e59f2008 ldr r2, [pc, #8] ; 36fc8 <msdos_find_node_by_cluster_num_in_fat_file+0x160><== NOT EXECUTED 36fbc: e59f3008 ldr r3, [pc, #8] ; 36fcc <msdos_find_node_by_cluster_num_in_fat_file+0x164><== NOT EXECUTED 36fc0: ebffc657 bl 28924 <__assert_func> <== NOT EXECUTED
0001f264 <msdos_format>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
1f264: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
1f268: e1a05001 mov r5, r1 <== NOT EXECUTED
1f26c: e24dde2d sub sp, sp, #720 ; 0x2d0 <== NOT EXECUTED
1f270: e1a06000 mov r6, r0 <== NOT EXECUTED
int ret_val = 0;
int fd = -1;
int i;
msdos_format_param_t fmt_params;
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
1f274: e1a03000 mov r3, r0 <== NOT EXECUTED 1f278: e59f2e00 ldr r2, [pc, #3584] ; 20080 <msdos_format+0xe1c> <== NOT EXECUTED 1f27c: e3a01001 mov r1, #1 <== NOT EXECUTED 1f280: e1a00005 mov r0, r5 <== NOT EXECUTED 1f284: ebffff69 bl 1f030 <msdos_format_printf> <== NOT EXECUTED
"formating: %s\n", devname);
/*
* sanity check on device
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f288: e1a00005 mov r0, r5 <== NOT EXECUTED 1f28c: e3a01002 mov r1, #2 <== NOT EXECUTED 1f290: e59f2dec ldr r2, [pc, #3564] ; 20084 <msdos_format+0xe20> <== NOT EXECUTED 1f294: e1a03006 mov r3, r6 <== NOT EXECUTED 1f298: ebffff64 bl 1f030 <msdos_format_printf> <== NOT EXECUTED
"stat check: %s\n", devname);
if (ret_val == 0) {
rc = stat(devname, &stat_buf);
1f29c: e1a00006 mov r0, r6 <== NOT EXECUTED 1f2a0: e28d1f9f add r1, sp, #636 ; 0x27c <== NOT EXECUTED 1f2a4: ebffa8e3 bl 9638 <stat> <== NOT EXECUTED
ret_val = rc;
}
/* rtems feature: no block devices, all are character devices */
if ((ret_val == 0) &&
1f2a8: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1f2ac: 1a000007 bne 1f2d0 <msdos_format+0x6c> <== NOT EXECUTED
(!S_ISBLK(stat_buf.st_mode))) {
1f2b0: e59d3288 ldr r3, [sp, #648] ; 0x288 <== NOT EXECUTED 1f2b4: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED 1f2b8: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED 1f2bc: 0a000010 beq 1f304 <msdos_format+0xa0> <== NOT EXECUTED
errno = ENOTTY;
1f2c0: eb008f4a bl 42ff0 <__errno> <== NOT EXECUTED 1f2c4: e3a03019 mov r3, #25 <== NOT EXECUTED 1f2c8: e5803000 str r3, [r0] <== NOT EXECUTED 1f2cc: e3e04000 mvn r4, #0 <== NOT EXECUTED 1f2d0: e3a07000 mov r7, #0 <== NOT EXECUTED
/* check that device is registered as block device and lock it */
if (ret_val == 0) {
dd = rtems_disk_obtain(stat_buf.st_rdev);
if (dd == NULL) {
errno = ENOTTY;
1f2d4: e3e06000 mvn r6, #0 <== NOT EXECUTED
0xe5);
}
/*
* create master boot record
*/
if (ret_val == 0) {
1f2d8: e3540000 cmp r4, #0 <== NOT EXECUTED 1f2dc: 0a00005b beq 1f450 <msdos_format+0x1ec> <== NOT EXECUTED
/*
* cleanup:
* sync and unlock disk
* free any data structures (not needed now)
*/
if (fd != -1) {
1f2e0: e3760001 cmn r6, #1 <== NOT EXECUTED
close(fd);
1f2e4: 11a00006 movne r0, r6 <== NOT EXECUTED 1f2e8: 1bffa16d blne 78a4 <close> <== NOT EXECUTED
}
if (dd != NULL) {
1f2ec: e3570000 cmp r7, #0 <== NOT EXECUTED
rtems_disk_release(dd);
1f2f0: 11a00007 movne r0, r7 <== NOT EXECUTED 1f2f4: 1bff9dcc blne 6a2c <rtems_disk_release> <== NOT EXECUTED
} return ret_val; }
1f2f8: e1a00004 mov r0, r4 <== NOT EXECUTED
1f2fc: e28dde2d add sp, sp, #720 ; 0x2d0 <== NOT EXECUTED
1f300: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
ret_val = -1;
}
/* check that device is registered as block device and lock it */
if (ret_val == 0) {
dd = rtems_disk_obtain(stat_buf.st_rdev);
1f304: e28d1fa5 add r1, sp, #660 ; 0x294 <== NOT EXECUTED
1f308: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
1f30c: ebff9d32 bl 67dc <rtems_disk_obtain> <== NOT EXECUTED
if (dd == NULL) {
1f310: e2507000 subs r7, r0, #0 <== NOT EXECUTED 1f314: 0a00034d beq 20050 <msdos_format+0xdec> <== NOT EXECUTED
/*
* open device for writing
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f318: e3a01002 mov r1, #2 <== NOT EXECUTED 1f31c: e59f2d64 ldr r2, [pc, #3428] ; 20088 <msdos_format+0xe24> <== NOT EXECUTED 1f320: e1a00005 mov r0, r5 <== NOT EXECUTED 1f324: ebffff41 bl 1f030 <msdos_format_printf> <== NOT EXECUTED
"open device\n");
fd = open(devname, O_RDWR);
1f328: e1a00006 mov r0, r6 <== NOT EXECUTED 1f32c: e3a01002 mov r1, #2 <== NOT EXECUTED 1f330: ebffa6f7 bl 8f14 <open> <== NOT EXECUTED
if (fd == -1)
1f334: e3700001 cmn r0, #1 <== NOT EXECUTED
* open device for writing
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"open device\n");
fd = open(devname, O_RDWR);
1f338: e1a06000 mov r6, r0 <== NOT EXECUTED
if (fd == -1)
1f33c: 01a04000 moveq r4, r0 <== NOT EXECUTED 1f340: 0affffe3 beq 1f2d4 <msdos_format+0x70> <== NOT EXECUTED
uint32_t fatdata_sect_cnt;
uint32_t onebit;
uint32_t sectors_per_cluster_adj = 0;
uint64_t total_size = 0;
memset(fmt_params,0,sizeof(*fmt_params));
1f344: e28dcf8b add ip, sp, #556 ; 0x22c <== NOT EXECUTED 1f348: e1a01004 mov r1, r4 <== NOT EXECUTED 1f34c: e3a02050 mov r2, #80 ; 0x50 <== NOT EXECUTED 1f350: e1a0000c mov r0, ip <== NOT EXECUTED 1f354: e58dc020 str ip, [sp, #32] <== NOT EXECUTED 1f358: eb009c5b bl 464cc <memset> <== NOT EXECUTED
/*
* this one is fixed in this implementation.
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
1f35c: e5973020 ldr r3, [r7, #32] <== NOT EXECUTED 1f360: e58d322c str r3, [sp, #556] ; 0x22c <== NOT EXECUTED
fmt_params->totl_sector_cnt = dd->size;
1f364: e597c01c ldr ip, [r7, #28] <== NOT EXECUTED
total_size = dd->block_size * dd->size;
1f368: e0080c93 mul r8, r3, ip <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f36c: e1a00005 mov r0, r5 <== NOT EXECUTED
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
fmt_params->totl_sector_cnt = dd->size;
total_size = dd->block_size * dd->size;
1f370: e3a09000 mov r9, #0 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f374: e3a01002 mov r1, #2 <== NOT EXECUTED 1f378: e59f2d0c ldr r2, [pc, #3340] ; 2008c <msdos_format+0xe28> <== NOT EXECUTED 1f37c: e58dc000 str ip, [sp] <== NOT EXECUTED
* this one is fixed in this implementation.
* At least one thing we don't have to magically guess...
*/
if (ret_val == 0) {
fmt_params->bytes_per_sector = dd->block_size;
fmt_params->totl_sector_cnt = dd->size;
1f380: e58dc230 str ip, [sp, #560] ; 0x230 <== NOT EXECUTED
total_size = dd->block_size * dd->size;
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f384: e98d0300 stmib sp, {r8, r9} <== NOT EXECUTED
1f388: ebffff28 bl 1f030 <msdos_format_printf> <== NOT EXECUTED
}
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
1f38c: e3550000 cmp r5, #0 <== NOT EXECUTED 1f390: 0a00025d beq 1fd0c <msdos_format+0xaa8> <== NOT EXECUTED
(rqdata->fat_num == 0)) {
1f394: e595c00c ldr ip, [r5, #12] <== NOT EXECUTED
}
/*
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
1f398: e35c0000 cmp ip, #0 <== NOT EXECUTED 1f39c: 0a000133 beq 1f870 <msdos_format+0x60c> <== NOT EXECUTED
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
}
else if (rqdata->fat_num <= 6) {
1f3a0: e35c0006 cmp ip, #6 <== NOT EXECUTED
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
1f3a4: 83a02016 movhi r2, #22 <== NOT EXECUTED
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
}
else if (rqdata->fat_num <= 6) {
1f3a8: 8a00023f bhi 1fcac <msdos_format+0xa48> <== NOT EXECUTED
fmt_params->fat_num = rqdata->fat_num;
1f3ac: e20cc0ff and ip, ip, #255 ; 0xff <== NOT EXECUTED
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f3b0: e1a0300c mov r3, ip <== NOT EXECUTED 1f3b4: e1a00005 mov r0, r5 <== NOT EXECUTED 1f3b8: e3a01002 mov r1, #2 <== NOT EXECUTED 1f3bc: e59f2ccc ldr r2, [pc, #3276] ; 20090 <msdos_format+0xe2c> <== NOT EXECUTED
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
}
else if (rqdata->fat_num <= 6) {
fmt_params->fat_num = rqdata->fat_num;
1f3c0: e5cdc25c strb ip, [sp, #604] ; 0x25c <== NOT EXECUTED
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f3c4: ebffff19 bl 1f030 <msdos_format_printf> <== NOT EXECUTED
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
1f3c8: e3a03001 mov r3, #1 <== NOT EXECUTED 1f3cc: e58d3238 str r3, [sp, #568] ; 0x238 <== NOT EXECUTED
if ((rqdata != NULL) &&
(rqdata->fattype == MSDOS_FMT_FAT12)) {
1f3d0: e5d53014 ldrb r3, [r5, #20] <== NOT EXECUTED
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
if ((rqdata != NULL) &&
1f3d4: e3530001 cmp r3, #1 <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT12)) {
fmt_params->fattype = FAT_FAT12;
1f3d8: 03a00000 moveq r0, #0 <== NOT EXECUTED 1f3dc: 05cd325e strbeq r3, [sp, #606] ; 0x25e <== NOT EXECUTED 1f3e0: 058d0014 streq r0, [sp, #20] <== NOT EXECUTED
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
if ((rqdata != NULL) &&
1f3e4: 0a00012f beq 1f8a8 <msdos_format+0x644> <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT12)) {
fmt_params->fattype = FAT_FAT12;
}
else if ((rqdata != NULL) &&
1f3e8: e3530002 cmp r3, #2 <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT16)) {
fmt_params->fattype = FAT_FAT16;
1f3ec: 03a01000 moveq r1, #0 <== NOT EXECUTED 1f3f0: 05cd325e strbeq r3, [sp, #606] ; 0x25e <== NOT EXECUTED 1f3f4: 058d1014 streq r1, [sp, #20] <== NOT EXECUTED
fmt_params->sectors_per_cluster = 1;
if ((rqdata != NULL) &&
(rqdata->fattype == MSDOS_FMT_FAT12)) {
fmt_params->fattype = FAT_FAT12;
}
else if ((rqdata != NULL) &&
1f3f8: 0a00012a beq 1f8a8 <msdos_format+0x644> <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT16)) {
fmt_params->fattype = FAT_FAT16;
}
else if ((rqdata != NULL) &&
1f3fc: e3530003 cmp r3, #3 <== NOT EXECUTED 1f400: 0a000124 beq 1f898 <msdos_format+0x634> <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
}
else if ((rqdata != NULL) &&
1f404: e3530000 cmp r3, #0 <== NOT EXECUTED 1f408: 1a000256 bne 1fd68 <msdos_format+0xb04> <== NOT EXECUTED
/*
* limiting values for disk size, fat type, sectors per cluster
* NOTE: maximum sect_per_clust is arbitrarily choosen with values that
* are a compromise concerning capacity and efficency
*/
if (fmt_params->totl_sector_cnt
1f40c: e59d2230 ldr r2, [sp, #560] ; 0x230 <== NOT EXECUTED 1f410: e3a03c7f mov r3, #32512 ; 0x7f00 <== NOT EXECUTED 1f414: e28330a7 add r3, r3, #167 ; 0xa7 <== NOT EXECUTED 1f418: e1520003 cmp r2, r3 <== NOT EXECUTED 1f41c: 8a0002b2 bhi 1feec <msdos_format+0xc88> <== NOT EXECUTED
< ((uint32_t)FAT_FAT12_MAX_CLN)*8) {
fmt_params->fattype = FAT_FAT12;
1f420: e3a03001 mov r3, #1 <== NOT EXECUTED 1f424: e5cd325e strb r3, [sp, #606] ; 0x25e <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
1f428: e3a03002 mov r3, #2 <== NOT EXECUTED 1f42c: e58d3238 str r3, [sp, #568] ; 0x238 <== NOT EXECUTED
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
1f430: e3550000 cmp r5, #0 <== NOT EXECUTED 1f434: 13a0c000 movne ip, #0 <== NOT EXECUTED 1f438: 158dc014 strne ip, [sp, #20] <== NOT EXECUTED 1f43c: 1a000119 bne 1f8a8 <msdos_format+0x644> <== NOT EXECUTED 1f440: e59d2238 ldr r2, [sp, #568] ; 0x238 <== NOT EXECUTED 1f444: e58d5014 str r5, [sp, #20] <== NOT EXECUTED 1f448: e1a03002 mov r3, r2 <== NOT EXECUTED 1f44c: ea00011a b 1f8bc <msdos_format+0x658> <== NOT EXECUTED
*/
if (ret_val == 0) {
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f450: e1a00005 mov r0, r5 <== NOT EXECUTED 1f454: e3a01002 mov r1, #2 <== NOT EXECUTED 1f458: e59f2c34 ldr r2, [pc, #3124] ; 20094 <msdos_format+0xe30> <== NOT EXECUTED 1f45c: ebfffef3 bl 1f030 <msdos_format_printf> <== NOT EXECUTED
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
1f460: e1a00006 mov r0, r6 <== NOT EXECUTED 1f464: e3a01000 mov r1, #0 <== NOT EXECUTED 1f468: e3a02000 mov r2, #0 <== NOT EXECUTED 1f46c: e3a03000 mov r3, #0 <== NOT EXECUTED
/*
* Read the current MBR to obtain the partition table.
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"read MRB sector\n");
ret_val = msdos_format_read_sec(fd,
1f470: e59d422c ldr r4, [sp, #556] ; 0x22c <== NOT EXECUTED
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
1f474: eb002a52 bl 29dc4 <lseek> <== NOT EXECUTED 1f478: e3510000 cmp r1, #0 <== NOT EXECUTED 1f47c: ba0000f9 blt 1f868 <msdos_format+0x604> <== NOT EXECUTED
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
1f480: e1a02004 mov r2, r4 <== NOT EXECUTED 1f484: e1a00006 mov r0, r6 <== NOT EXECUTED 1f488: e28d102c add r1, sp, #44 ; 0x2c <== NOT EXECUTED 1f48c: ebffa754 bl 91e4 <read> <== NOT EXECUTED 1f490: e3500000 cmp r0, #0 <== NOT EXECUTED 1f494: ba0000f3 blt 1f868 <msdos_format+0x604> <== NOT EXECUTED
ret_val = msdos_format_read_sec(fd,
0,
fmt_params.bytes_per_sector,
tmp_sec);
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f498: e1a00005 mov r0, r5 <== NOT EXECUTED 1f49c: e3a01002 mov r1, #2 <== NOT EXECUTED 1f4a0: e59f2bf0 ldr r2, [pc, #3056] ; 20098 <msdos_format+0xe34> <== NOT EXECUTED 1f4a4: ebfffee1 bl 1f030 <msdos_format_printf> <== NOT EXECUTED
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
/* store total sector count in either 16 or 32 bit field in mbr */
if (fmt_params->totl_sector_cnt < 0x10000) {
1f4a8: e59d3230 ldr r3, [sp, #560] ; 0x230 <== NOT EXECUTED 1f4ac: e3530801 cmp r3, #65536 ; 0x10000 <== NOT EXECUTED 1f4b0: 3a00021d bcc 1fd2c <msdos_format+0xac8> <== NOT EXECUTED
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
ret_val = -1;
}
if (ret_val == 0) {
if (0 > read(fd,buffer,sector_size)) {
1f4b4: e1a02803 lsl r2, r3, #16 <== NOT EXECUTED 1f4b8: e1a01823 lsr r1, r3, #16 <== NOT EXECUTED 1f4bc: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED 1f4c0: e3a0c000 mov ip, #0 <== NOT EXECUTED 1f4c4: e1a02422 lsr r2, r2, #8 <== NOT EXECUTED 1f4c8: e20110ff and r1, r1, #255 ; 0xff <== NOT EXECUTED 1f4cc: e1a0ac23 lsr sl, r3, #24 <== NOT EXECUTED 1f4d0: e20330ff and r3, r3, #255 ; 0xff <== NOT EXECUTED 1f4d4: e58dc00c str ip, [sp, #12] <== NOT EXECUTED 1f4d8: e58d2018 str r2, [sp, #24] <== NOT EXECUTED 1f4dc: e58d1014 str r1, [sp, #20] <== NOT EXECUTED 1f4e0: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 1f4e4: e58dc01c str ip, [sp, #28] <== NOT EXECUTED
* finally we are there: let's fill in the values into the MBR * but first clear the MRB leaving the partition table. */ #define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be #define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16) memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET);
1f4e8: e3a08000 mov r8, #0 <== NOT EXECUTED 1f4ec: e28d402c add r4, sp, #44 ; 0x2c <== NOT EXECUTED 1f4f0: e3a02f6f mov r2, #444 ; 0x1bc <== NOT EXECUTED 1f4f4: e2822002 add r2, r2, #2 <== NOT EXECUTED 1f4f8: e1a01008 mov r1, r8 <== NOT EXECUTED 1f4fc: e1a00004 mov r0, r4 <== NOT EXECUTED 1f500: eb009bf1 bl 464cc <memset> <== NOT EXECUTED
* with 0xEB,.... */ /* * fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
1f504: e28d0f8b add r0, sp, #556 ; 0x22c <== NOT EXECUTED 1f508: e58d0020 str r0, [sp, #32] <== NOT EXECUTED 1f50c: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED
* but first clear the MRB leaving the partition table. */ #define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be #define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16) memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET); memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
1f510: e3a03f7f mov r3, #508 ; 0x1fc <== NOT EXECUTED 1f514: e2833002 add r3, r3, #2 <== NOT EXECUTED
* with 0xEB,.... */ /* * fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
1f518: e2821033 add r1, r2, #51 ; 0x33 <== NOT EXECUTED
* but first clear the MRB leaving the partition table. */ #define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be #define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16) memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET); memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
1f51c: e18480b3 strh r8, [r4, r3] <== NOT EXECUTED
* with 0xEB,.... */ /* * fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr),
1f520: e3a02008 mov r2, #8 <== NOT EXECUTED 1f524: e2840003 add r0, r4, #3 <== NOT EXECUTED 1f528: eb009b60 bl 462b0 <memcpy> <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
1f52c: e59db244 ldr fp, [sp, #580] ; 0x244 <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16); FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
1f530: e5dd025d ldrb r0, [sp, #605] ; 0x25d <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
1f534: e1a0c42b lsr ip, fp, #8 <== NOT EXECUTED 1f538: e5cdc03e strb ip, [sp, #62] ; 0x3e <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16); FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
1f53c: e5cd0041 strb r0, [sp, #65] ; 0x41 <== NOT EXECUTED
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
1f540: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
1f544: e3e00000 mvn r0, #0 <== NOT EXECUTED
* fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr), fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
1f548: e59d122c ldr r1, [sp, #556] ; 0x22c <== NOT EXECUTED
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
1f54c: e5cd0044 strb r0, [sp, #68] ; 0x44 <== NOT EXECUTED
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
1f550: e3a00006 mov r0, #6 <== NOT EXECUTED
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
1f554: e5cdc03f strb ip, [sp, #63] ; 0x3f <== NOT EXECUTED
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
1f558: e5cd0046 strb r0, [sp, #70] ; 0x46 <== NOT EXECUTED
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
1f55c: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
1f560: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr), fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector); FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster); FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
1f564: e59d2234 ldr r2, [sp, #564] ; 0x234 <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
1f568: e5dd325e ldrb r3, [sp, #606] ; 0x25e <== NOT EXECUTED
* fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr), fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
1f56c: e1a09421 lsr r9, r1, #8 <== NOT EXECUTED 1f570: e5cd9038 strb r9, [sp, #56] ; 0x38 <== NOT EXECUTED
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
1f574: e5cdc040 strb ip, [sp, #64] ; 0x40 <== NOT EXECUTED
*/ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr), fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector); FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
1f578: e59d9238 ldr r9, [sp, #568] ; 0x238 <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
1f57c: e5cd004c strb r0, [sp, #76] ; 0x4c <== NOT EXECUTED
1f580: e28d0014 add r0, sp, #20 <== NOT EXECUTED
1f584: e8901001 ldm r0, {r0, ip} <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr), fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector); FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster); FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
1f588: e1a0e422 lsr lr, r2, #8 <== NOT EXECUTED
* fill OEMName */ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr), fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
1f58c: e5cd1037 strb r1, [sp, #55] ; 0x37 <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster); FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
1f590: e5cd203a strb r2, [sp, #58] ; 0x3a <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
1f594: e3530004 cmp r3, #4 <== NOT EXECUTED
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
1f598: e3a01002 mov r1, #2 <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
1f59c: e3a02001 mov r2, #1 <== NOT EXECUTED
*/ memcpy(FAT_GET_ADDR_BR_OEMNAME(mbr), fmt_params->OEMName, FAT_BR_OEMNAME_SIZE); FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector); FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
1f5a0: e5cd9039 strb r9, [sp, #57] ; 0x39 <== NOT EXECUTED
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
1f5a4: e5cde03b strb lr, [sp, #59] ; 0x3b <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
1f5a8: e5cdc04d strb ip, [sp, #77] ; 0x4d <== NOT EXECUTED 1f5ac: e5cd004e strb r0, [sp, #78] ; 0x4e <== NOT EXECUTED 1f5b0: e5cda04f strb sl, [sp, #79] ; 0x4f <== NOT EXECUTED
FAT_SET_BR_BYTES_PER_SECTOR(mbr , fmt_params->bytes_per_sector);
FAT_SET_BR_SECTORS_PER_CLUSTER(mbr , fmt_params->sectors_per_cluster);
FAT_SET_BR_RESERVED_SECTORS_NUM(mbr, fmt_params->rsvd_sector_cnt);
/* number of FATs on medium */
FAT_SET_BR_FAT_NUM(mbr , 2); /* standard/recommended value */
1f5b4: e5cd103c strb r1, [sp, #60] ; 0x3c <== NOT EXECUTED
FAT_SET_BR_FILES_PER_ROOT_DIR(mbr , fmt_params->files_per_root_dir);
1f5b8: e5cdb03d strb fp, [sp, #61] ; 0x3d <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
1f5bc: e5cd8045 strb r8, [sp, #69] ; 0x45 <== NOT EXECUTED
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
1f5c0: e5cd8047 strb r8, [sp, #71] ; 0x47 <== NOT EXECUTED
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
1f5c4: e5cd2048 strb r2, [sp, #72] ; 0x48 <== NOT EXECUTED 1f5c8: e5cd8049 strb r8, [sp, #73] ; 0x49 <== NOT EXECUTED 1f5cc: e5cd804a strb r8, [sp, #74] ; 0x4a <== NOT EXECUTED
* but first clear the MRB leaving the partition table. */ #define RTEMS_IDE_PARTITION_TABLE_OFFSET 0x1be #define RTEMS_IDE_PARTITION_TABLE_SIZE (4 * 16) memset(mbr,0,RTEMS_IDE_PARTITION_TABLE_OFFSET); memset(mbr + RTEMS_IDE_PARTITION_TABLE_OFFSET + RTEMS_IDE_PARTITION_TABLE_SIZE,
1f5d0: e1a03008 mov r3, r8 <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM16(mbr , total_sectors_num16);
FAT_SET_BR_MEDIA(mbr , fmt_params->media_code);
FAT_SET_BR_SECTORS_PER_TRACK(mbr , 255); /* only needed for INT13... */
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
1f5d4: e5cd804b strb r8, [sp, #75] ; 0x4b <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
1f5d8: 0a00025d beq 1ff54 <msdos_format+0xcf0> <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
1f5dc: e59db23c ldr fp, [sp, #572] ; 0x23c <== NOT EXECUTED
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
1f5e0: e59dc278 ldr ip, [sp, #632] ; 0x278 <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
1f5e4: e59d0020 ldr r0, [sp, #32] <== NOT EXECUTED
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
1f5e8: e1a0e42b lsr lr, fp, #8 <== NOT EXECUTED
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
1f5ec: e280103c add r1, r0, #60 ; 0x3c <== NOT EXECUTED
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
1f5f0: e1a09c2c lsr r9, ip, #24 <== NOT EXECUTED 1f5f4: e1a0842c lsr r8, ip, #8 <== NOT EXECUTED 1f5f8: e1a0a82c lsr sl, ip, #16 <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
1f5fc: e3a0200b mov r2, #11 <== NOT EXECUTED
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
1f600: e5cde043 strb lr, [sp, #67] ; 0x43 <== NOT EXECUTED
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
1f604: e284002b add r0, r4, #43 ; 0x2b <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
1f608: e3a0e029 mov lr, #41 ; 0x29 <== NOT EXECUTED
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
1f60c: e5cd3051 strb r3, [sp, #81] ; 0x51 <== NOT EXECUTED
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
1f610: e5cd3050 strb r3, [sp, #80] ; 0x50 <== NOT EXECUTED
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
1f614: e5cde052 strb lr, [sp, #82] ; 0x52 <== NOT EXECUTED
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
1f618: e5cd8054 strb r8, [sp, #84] ; 0x54 <== NOT EXECUTED 1f61c: e5cda055 strb sl, [sp, #85] ; 0x55 <== NOT EXECUTED 1f620: e5cd9056 strb r9, [sp, #86] ; 0x56 <== NOT EXECUTED
FAT_SET_BR_NUMBER_OF_HEADS(mbr , 6); /* only needed for INT13... */
FAT_SET_BR_HIDDEN_SECTORS(mbr , 1); /* only needed for INT13... */
FAT_SET_BR_TOTAL_SECTORS_NUM32(mbr , total_sectors_num32);
if (fmt_params->fattype != FAT_FAT32) {
FAT_SET_BR_SECTORS_PER_FAT(mbr ,fmt_params->sectors_per_fat);
1f624: e5cdb042 strb fp, [sp, #66] ; 0x42 <== NOT EXECUTED
FAT_SET_BR_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_BOOTSIG(mbr , FAT_BR_BOOTSIG_VAL);
FAT_SET_BR_VOLID(mbr , fmt_params->vol_id); /* volume id */
1f628: e5cdc053 strb ip, [sp, #83] ; 0x53 <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_VOLLAB(mbr),
1f62c: eb009b1f bl 462b0 <memcpy> <== NOT EXECUTED
fmt_params->VolLabel,
FAT_BR_VOLLAB_SIZE);
memcpy(FAT_GET_ADDR_BR_FILSYSTYPE(mbr),
1f630: e5dd125e ldrb r1, [sp, #606] ; 0x25e <== NOT EXECUTED 1f634: e59f2a60 ldr r2, [pc, #2656] ; 2009c <msdos_format+0xe38> <== NOT EXECUTED 1f638: e59f3a60 ldr r3, [pc, #2656] ; 200a0 <msdos_format+0xe3c> <== NOT EXECUTED 1f63c: e3510001 cmp r1, #1 <== NOT EXECUTED 1f640: 01a01002 moveq r1, r2 <== NOT EXECUTED 1f644: 11a01003 movne r1, r3 <== NOT EXECUTED 1f648: e2840036 add r0, r4, #54 ; 0x36 <== NOT EXECUTED 1f64c: e3a02008 mov r2, #8 <== NOT EXECUTED 1f650: eb009b16 bl 462b0 <memcpy> <== NOT EXECUTED
FAT_BR_FILSYSTYPE_SIZE); } /* * add boot record signature */ FAT_SET_BR_SIGNATURE(mbr, FAT_BR_SIGNATURE_VAL);
1f654: e3a03055 mov r3, #85 ; 0x55 <== NOT EXECUTED 1f658: e5cd322a strb r3, [sp, #554] ; 0x22a <== NOT EXECUTED 1f65c: e3e03055 mvn r3, #85 ; 0x55 <== NOT EXECUTED 1f660: e5cd322b strb r3, [sp, #555] ; 0x22b <== NOT EXECUTED
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
1f664: e3e03014 mvn r3, #20 <== NOT EXECUTED 1f668: e5cd302c strb r3, [sp, #44] ; 0x2c <== NOT EXECUTED
FAT_SET_VAL8(mbr,1,0x3c);
1f66c: e3a0303c mov r3, #60 ; 0x3c <== NOT EXECUTED
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f670: e1a00005 mov r0, r5 <== NOT EXECUTED 1f674: e3a01002 mov r1, #2 <== NOT EXECUTED 1f678: e59f2a24 ldr r2, [pc, #2596] ; 200a4 <msdos_format+0xe40> <== NOT EXECUTED
/*
* add jump to boot loader at start of sector
*/
FAT_SET_VAL8(mbr,0,0xeb);
FAT_SET_VAL8(mbr,1,0x3c);
1f67c: e5cd302d strb r3, [sp, #45] ; 0x2d <== NOT EXECUTED
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
1f680: e28d802c add r8, sp, #44 ; 0x2c <== NOT EXECUTED
/* * add jump to boot loader at start of sector */ FAT_SET_VAL8(mbr,0,0xeb); FAT_SET_VAL8(mbr,1,0x3c); FAT_SET_VAL8(mbr,2,0x90);
1f684: e3e0306f mvn r3, #111 ; 0x6f <== NOT EXECUTED 1f688: e5cd302e strb r3, [sp, #46] ; 0x2e <== NOT EXECUTED
/*
* write master boot record to disk
* also write copy of MBR to disk
*/
if (ret_val == 0) {
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f68c: ebfffe67 bl 1f030 <msdos_format_printf> <== NOT EXECUTED
"write MRB sector\n");
ret_val = msdos_format_write_sec(fd,
1f690: e1a00006 mov r0, r6 <== NOT EXECUTED 1f694: e3a01000 mov r1, #0 <== NOT EXECUTED 1f698: e59d222c ldr r2, [sp, #556] ; 0x22c <== NOT EXECUTED 1f69c: e1a03008 mov r3, r8 <== NOT EXECUTED 1f6a0: ebfffe79 bl 1f08c <msdos_format_write_sec> <== NOT EXECUTED
0,
fmt_params.bytes_per_sector,
tmp_sec);
}
if ((ret_val == 0) &&
1f6a4: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1f6a8: 1affff0c bne 1f2e0 <msdos_format+0x7c> <== NOT EXECUTED 1f6ac: e59d3254 ldr r3, [sp, #596] ; 0x254 <== NOT EXECUTED 1f6b0: e3530000 cmp r3, #0 <== NOT EXECUTED 1f6b4: 1a0001d9 bne 1fe20 <msdos_format+0xbbc> <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
1f6b8: e59d3258 ldr r3, [sp, #600] ; 0x258 <== NOT EXECUTED 1f6bc: e3530000 cmp r3, #0 <== NOT EXECUTED 1f6c0: 1a0001ae bne 1fd80 <msdos_format+0xb1c> <== NOT EXECUTED
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
ret_val = msdos_format_fill_sectors
1f6c4: e59d223c ldr r2, [sp, #572] ; 0x23c <== NOT EXECUTED 1f6c8: e59dc22c ldr ip, [sp, #556] ; 0x22c <== NOT EXECUTED 1f6cc: e5dd325c ldrb r3, [sp, #604] ; 0x25c <== NOT EXECUTED 1f6d0: e58dc000 str ip, [sp] <== NOT EXECUTED 1f6d4: e0030392 mul r3, r2, r3 <== NOT EXECUTED 1f6d8: e3a0c000 mov ip, #0 <== NOT EXECUTED 1f6dc: e59d2234 ldr r2, [sp, #564] ; 0x234 <== NOT EXECUTED 1f6e0: e1a00005 mov r0, r5 <== NOT EXECUTED 1f6e4: e1a01006 mov r1, r6 <== NOT EXECUTED 1f6e8: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 1f6ec: ebfffe7a bl 1f0dc <msdos_format_fill_sectors> <== NOT EXECUTED
}
/*
* clear/init root directory
* -> write all directory sectors as 0x00
*/
if (ret_val == 0) {
1f6f0: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1f6f4: 1afffef9 bne 1f2e0 <msdos_format+0x7c> <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
1f6f8: e59dc22c ldr ip, [sp, #556] ; 0x22c <== NOT EXECUTED
1f6fc: e1a00005 mov r0, r5 <== NOT EXECUTED
1f700: e28d2f93 add r2, sp, #588 ; 0x24c <== NOT EXECUTED
1f704: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
1f708: e1a01006 mov r1, r6 <== NOT EXECUTED
1f70c: e58d4004 str r4, [sp, #4] <== NOT EXECUTED
1f710: e58dc000 str ip, [sp] <== NOT EXECUTED
1f714: ebfffe70 bl 1f0dc <msdos_format_fill_sectors> <== NOT EXECUTED
0x00);
}
/*
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
1f718: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1f71c: 1afffeef bne 1f2e0 <msdos_format+0x7c> <== NOT EXECUTED 1f720: e5dd3274 ldrb r3, [sp, #628] ; 0x274 <== NOT EXECUTED 1f724: e3530000 cmp r3, #0 <== NOT EXECUTED 1f728: 0afffeec beq 1f2e0 <msdos_format+0x7c> <== NOT EXECUTED
memset(tmp_sec,0,sizeof(tmp_sec));
1f72c: e28d502c add r5, sp, #44 ; 0x2c <== NOT EXECUTED 1f730: e1a01004 mov r1, r4 <== NOT EXECUTED 1f734: e3a02c02 mov r2, #512 ; 0x200 <== NOT EXECUTED 1f738: e1a00005 mov r0, r5 <== NOT EXECUTED 1f73c: eb009b62 bl 464cc <memset> <== NOT EXECUTED
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
1f740: e59d0020 ldr r0, [sp, #32] <== NOT EXECUTED
1f744: e280303c add r3, r0, #60 ; 0x3c <== NOT EXECUTED
1f748: e8930007 ldm r3, {r0, r1, r2} <== NOT EXECUTED
1f74c: e1a03005 mov r3, r5 <== NOT EXECUTED
1f750: e8a30003 stmia r3!, {r0, r1} <== NOT EXECUTED
1f754: e1a0c822 lsr ip, r2, #16 <== NOT EXECUTED
1f758: e1c320b0 strh r2, [r3] <== NOT EXECUTED
1f75c: e5c5c00a strb ip, [r5, #10] <== NOT EXECUTED
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
ret_val = msdos_format_write_sec
1f760: e1a00006 mov r0, r6 <== NOT EXECUTED
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
1f764: e3a0c008 mov ip, #8 <== NOT EXECUTED
ret_val = msdos_format_write_sec
1f768: e59d124c ldr r1, [sp, #588] ; 0x24c <== NOT EXECUTED 1f76c: e59d222c ldr r2, [sp, #556] ; 0x22c <== NOT EXECUTED 1f770: e1a03005 mov r3, r5 <== NOT EXECUTED
* write volume label to first entry of directory
*/
if ((ret_val == 0) && fmt_params.VolLabel_present) {
memset(tmp_sec,0,sizeof(tmp_sec));
memcpy(MSDOS_DIR_NAME(tmp_sec),fmt_params.VolLabel,MSDOS_SHORT_NAME_LEN);
*MSDOS_DIR_ATTR(tmp_sec) = MSDOS_ATTR_VOLUME_ID;
1f774: e5cdc037 strb ip, [sp, #55] ; 0x37 <== NOT EXECUTED
ret_val = msdos_format_write_sec
1f778: ebfffe43 bl 1f08c <msdos_format_write_sec> <== NOT EXECUTED
/*
* write FAT entry 0 as (0xffffff00|Media_type)EOC,
* write FAT entry 1 as EOC
* allocate directory in a FAT32 FS
*/
if ((ret_val == 0) && fmt_params.VolLabel_present){
1f77c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1f780: 1afffed6 bne 1f2e0 <msdos_format+0x7c> <== NOT EXECUTED 1f784: e5dd3274 ldrb r3, [sp, #628] ; 0x274 <== NOT EXECUTED 1f788: e3530000 cmp r3, #0 <== NOT EXECUTED 1f78c: 0afffed3 beq 1f2e0 <msdos_format+0x7c> <== NOT EXECUTED
/*
* empty sector: all clusters are free/do not link further on
*/
memset(tmp_sec,0,sizeof(tmp_sec));
1f790: e1a00005 mov r0, r5 <== NOT EXECUTED 1f794: e1a01004 mov r1, r4 <== NOT EXECUTED 1f798: e3a02c02 mov r2, #512 ; 0x200 <== NOT EXECUTED 1f79c: eb009b4a bl 464cc <memset> <== NOT EXECUTED
switch(fmt_params.fattype) {
1f7a0: e5dd325e ldrb r3, [sp, #606] ; 0x25e <== NOT EXECUTED 1f7a4: e3530002 cmp r3, #2 <== NOT EXECUTED 1f7a8: 0a0001ba beq 1fe98 <msdos_format+0xc34> <== NOT EXECUTED 1f7ac: e3530004 cmp r3, #4 <== NOT EXECUTED 1f7b0: 0a0001a8 beq 1fe58 <msdos_format+0xbf4> <== NOT EXECUTED 1f7b4: e3530001 cmp r3, #1 <== NOT EXECUTED 1f7b8: 0a0001c1 beq 1fec4 <msdos_format+0xc60> <== NOT EXECUTED
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
break;
default:
ret_val = -1;
errno = EINVAL;
1f7bc: eb008e0b bl 42ff0 <__errno> <== NOT EXECUTED 1f7c0: e3a03016 mov r3, #22 <== NOT EXECUTED 1f7c4: e5803000 str r3, [r0] <== NOT EXECUTED
}
if (fmt_params.fattype == FAT_FAT32) {
1f7c8: e5dd325e ldrb r3, [sp, #606] ; 0x25e <== NOT EXECUTED 1f7cc: e3530004 cmp r3, #4 <== NOT EXECUTED 1f7d0: 1a000024 bne 1f868 <msdos_format+0x604> <== NOT EXECUTED 1f7d4: e3e04000 mvn r4, #0 <== NOT EXECUTED
/*
* only first valid cluster (cluster number 2) belongs
* to root directory, and is end of chain
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
1f7d8: e3e01007 mvn r1, #7 <== NOT EXECUTED 1f7dc: e5dd225c ldrb r2, [sp, #604] ; 0x25c <== NOT EXECUTED 1f7e0: e3e03000 mvn r3, #0 <== NOT EXECUTED 1f7e4: e5cd1034 strb r1, [sp, #52] ; 0x34 <== NOT EXECUTED 1f7e8: e3a0100f mov r1, #15 <== NOT EXECUTED 1f7ec: e5cd3036 strb r3, [sp, #54] ; 0x36 <== NOT EXECUTED 1f7f0: e5cd3035 strb r3, [sp, #53] ; 0x35 <== NOT EXECUTED 1f7f4: e5cd1037 strb r1, [sp, #55] ; 0x37 <== NOT EXECUTED 1f7f8: e2743001 rsbs r3, r4, #1 <== NOT EXECUTED 1f7fc: 33a03000 movcc r3, #0 <== NOT EXECUTED 1f800: e3520000 cmp r2, #0 <== NOT EXECUTED 1f804: 03a03000 moveq r3, #0 <== NOT EXECUTED
}
for (i = 0;
1f808: e3530000 cmp r3, #0 <== NOT EXECUTED 1f80c: 0afffeb3 beq 1f2e0 <msdos_format+0x7c> <== NOT EXECUTED 1f810: e59d123c ldr r1, [sp, #572] ; 0x23c <== NOT EXECUTED 1f814: e3a05000 mov r5, #0 <== NOT EXECUTED
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
1f818: e28d802c add r8, sp, #44 ; 0x2c <== NOT EXECUTED 1f81c: ea000000 b 1f824 <msdos_format+0x5c0> <== NOT EXECUTED
* to root directory, and is end of chain
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
1f820: e59d123c ldr r1, [sp, #572] ; 0x23c <== NOT EXECUTED
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
ret_val = msdos_format_write_sec
1f824: e59d3234 ldr r3, [sp, #564] ; 0x234 <== NOT EXECUTED 1f828: e59d222c ldr r2, [sp, #556] ; 0x22c <== NOT EXECUTED 1f82c: e0213195 mla r1, r5, r1, r3 <== NOT EXECUTED 1f830: e1a00006 mov r0, r6 <== NOT EXECUTED 1f834: e1a03008 mov r3, r8 <== NOT EXECUTED 1f838: ebfffe13 bl 1f08c <msdos_format_write_sec> <== NOT EXECUTED
* to root directory, and is end of chain
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
1f83c: e5dd325c ldrb r3, [sp, #604] ; 0x25c <== NOT EXECUTED
(i < fmt_params.fat_num) && (ret_val == 0);
i++) {
1f840: e2855001 add r5, r5, #1 <== NOT EXECUTED
* to root directory, and is end of chain
* mark this in every copy of the FAT
*/
FAT_SET_VAL32(tmp_sec,8,FAT_FAT32_EOC);
}
for (i = 0;
1f844: e1530005 cmp r3, r5 <== NOT EXECUTED 1f848: d3a02000 movle r2, #0 <== NOT EXECUTED 1f84c: c3a02001 movgt r2, #1 <== NOT EXECUTED 1f850: e3500000 cmp r0, #0 <== NOT EXECUTED 1f854: 13a02000 movne r2, #0 <== NOT EXECUTED 1f858: e3520000 cmp r2, #0 <== NOT EXECUTED 1f85c: 1affffef bne 1f820 <msdos_format+0x5bc> <== NOT EXECUTED 1f860: e1a04000 mov r4, r0 <== NOT EXECUTED 1f864: eafffe9d b 1f2e0 <msdos_format+0x7c> <== NOT EXECUTED 1f868: e3e04000 mvn r4, #0 <== NOT EXECUTED 1f86c: eafffe9b b 1f2e0 <msdos_format+0x7c> <== NOT EXECUTED
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
1f870: e3a0c002 mov ip, #2 <== NOT EXECUTED
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f874: e1a0300c mov r3, ip <== NOT EXECUTED 1f878: e1a0100c mov r1, ip <== NOT EXECUTED 1f87c: e1a00005 mov r0, r5 <== NOT EXECUTED 1f880: e59f2808 ldr r2, [pc, #2056] ; 20090 <msdos_format+0xe2c> <== NOT EXECUTED
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
1f884: e5cdc25c strb ip, [sp, #604] ; 0x25c <== NOT EXECUTED
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f888: ebfffde8 bl 1f030 <msdos_format_printf> <== NOT EXECUTED
/*
* determine FAT type and sectors per cluster
* depends on
*/
if (ret_val == 0) {
fmt_params->sectors_per_cluster = 1;
1f88c: e3a03001 mov r3, #1 <== NOT EXECUTED 1f890: e58d3238 str r3, [sp, #568] ; 0x238 <== NOT EXECUTED 1f894: eafffecd b 1f3d0 <msdos_format+0x16c> <== NOT EXECUTED
(rqdata->fattype == MSDOS_FMT_FAT16)) {
fmt_params->fattype = FAT_FAT16;
}
else if ((rqdata != NULL) &&
(rqdata->fattype == MSDOS_FMT_FAT32)) {
fmt_params->fattype = FAT_FAT32;
1f898: e3a03004 mov r3, #4 <== NOT EXECUTED 1f89c: e3a02000 mov r2, #0 <== NOT EXECUTED 1f8a0: e5cd325e strb r3, [sp, #606] ; 0x25e <== NOT EXECUTED 1f8a4: e58d2014 str r2, [sp, #20] <== NOT EXECUTED
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
(rqdata->sectors_per_cluster > 0)) {
1f8a8: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
}
}
/*
* try to use user requested cluster size
*/
if ((rqdata != NULL) &&
1f8ac: e3530000 cmp r3, #0 <== NOT EXECUTED 1f8b0: 059d2238 ldreq r2, [sp, #568] ; 0x238 <== NOT EXECUTED 1f8b4: 11a02003 movne r2, r3 <== NOT EXECUTED 1f8b8: 01a03002 moveq r3, r2 <== NOT EXECUTED
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
if (fmt_params->sectors_per_cluster >= onebit) {
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
<= 32768L/fmt_params->bytes_per_sector) {
1f8bc: e59da22c ldr sl, [sp, #556] ; 0x22c <== NOT EXECUTED 1f8c0: e3a04080 mov r4, #128 ; 0x80 <== NOT EXECUTED
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
if (fmt_params->sectors_per_cluster >= onebit) {
1f8c4: e1540003 cmp r4, r3 <== NOT EXECUTED
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
<= 32768L/fmt_params->bytes_per_sector) {
1f8c8: e3a08000 mov r8, #0 <== NOT EXECUTED
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
if (fmt_params->sectors_per_cluster >= onebit) {
fmt_params->sectors_per_cluster = onebit;
if (fmt_params->sectors_per_cluster
1f8cc: e1a0100a mov r1, sl <== NOT EXECUTED 1f8d0: e3a00902 mov r0, #32768 ; 0x8000 <== NOT EXECUTED
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
if (fmt_params->sectors_per_cluster >= onebit) {
1f8d4: 81a03002 movhi r3, r2 <== NOT EXECUTED 1f8d8: 8a000003 bhi 1f8ec <msdos_format+0x688> <== NOT EXECUTED
fmt_params->sectors_per_cluster = onebit; if (fmt_params->sectors_per_cluster
1f8dc: eb00ed81 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 1f8e0: e1500004 cmp r0, r4 <== NOT EXECUTED 1f8e4: 2a00000d bcs 1f920 <msdos_format+0x6bc> <== NOT EXECUTED 1f8e8: e1a03004 mov r3, r4 <== NOT EXECUTED
* check sectors per cluster.
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
1f8ec: e2888001 add r8, r8, #1 <== NOT EXECUTED 1f8f0: e3580008 cmp r8, #8 <== NOT EXECUTED 1f8f4: e1a040a4 lsr r4, r4, #1 <== NOT EXECUTED 1f8f8: 0a0001de beq 20078 <msdos_format+0xe14> <== NOT EXECUTED 1f8fc: e1a02003 mov r2, r3 <== NOT EXECUTED
if (fmt_params->sectors_per_cluster >= onebit) {
1f900: e1540003 cmp r4, r3 <== NOT EXECUTED
fmt_params->sectors_per_cluster = onebit; if (fmt_params->sectors_per_cluster
1f904: e1a0100a mov r1, sl <== NOT EXECUTED 1f908: e3a00902 mov r0, #32768 ; 0x8000 <== NOT EXECUTED
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
if (fmt_params->sectors_per_cluster >= onebit) {
1f90c: 81a03002 movhi r3, r2 <== NOT EXECUTED 1f910: 8afffff5 bhi 1f8ec <msdos_format+0x688> <== NOT EXECUTED
fmt_params->sectors_per_cluster = onebit; if (fmt_params->sectors_per_cluster
1f914: eb00ed73 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 1f918: e1500004 cmp r0, r4 <== NOT EXECUTED 1f91c: 3afffff1 bcc 1f8e8 <msdos_format+0x684> <== NOT EXECUTED
* check sectors per cluster.
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
1f920: e58d4238 str r4, [sp, #568] ; 0x238 <== NOT EXECUTED
}
}
}
}
if (ret_val == 0) {
1f924: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED 1f928: e3500000 cmp r0, #0 <== NOT EXECUTED 1f92c: 1a0000f1 bne 1fcf8 <msdos_format+0xa94> <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f930: e1a00005 mov r0, r5 <== NOT EXECUTED 1f934: e3a01002 mov r1, #2 <== NOT EXECUTED 1f938: e59f2768 ldr r2, [pc, #1896] ; 200a8 <msdos_format+0xe44> <== NOT EXECUTED 1f93c: e59d3238 ldr r3, [sp, #568] ; 0x238 <== NOT EXECUTED 1f940: ebfffdba bl 1f030 <msdos_format_printf> <== NOT EXECUTED
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
1f944: e5dda25e ldrb sl, [sp, #606] ; 0x25e <== NOT EXECUTED 1f948: e35a0004 cmp sl, #4 <== NOT EXECUTED 1f94c: 0a0001b4 beq 20024 <msdos_format+0xdc0> <== NOT EXECUTED
fmt_params->fsinfo_sec = 1;
}
else {
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
1f950: e3a03001 mov r3, #1 <== NOT EXECUTED
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
1f954: e3550000 cmp r5, #0 <== NOT EXECUTED
fmt_params->fsinfo_sec = 1;
}
else {
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
1f958: e58d3234 str r3, [sp, #564] ; 0x234 <== NOT EXECUTED
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
1f95c: 0a0000fc beq 1fd54 <msdos_format+0xaf0> <== NOT EXECUTED
(rqdata->files_per_root_dir > 0)) {
1f960: e5954010 ldr r4, [r5, #16] <== NOT EXECUTED
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
1f964: e3540000 cmp r4, #0 <== NOT EXECUTED
(rqdata->files_per_root_dir > 0)) {
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
1f968: 12444001 subne r4, r4, #1 <== NOT EXECUTED
/* recommended: for FAT12/FAT16, always set reserved sector count to 1 */
fmt_params->rsvd_sector_cnt = 1;
/* recommended: for FAT16, set files per root directory to 512 */
/* for FAT12/FAT16, set files per root directory */
/* must fill up an even count of sectors */
if ((rqdata != NULL) &&
1f96c: 0a0000f8 beq 1fd54 <msdos_format+0xaf0> <== NOT EXECUTED
}
else {
fmt_params->files_per_root_dir = 64;
}
}
fmt_params->files_per_root_dir = (fmt_params->files_per_root_dir +
1f970: e59d922c ldr r9, [sp, #556] ; 0x22c <== NOT EXECUTED 1f974: e1a01089 lsl r1, r9, #1 <== NOT EXECUTED 1f978: e1a012a1 lsr r1, r1, #5 <== NOT EXECUTED 1f97c: e0844001 add r4, r4, r1 <== NOT EXECUTED
(2*fmt_params->bytes_per_sector/
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
1f980: e1a00004 mov r0, r4 <== NOT EXECUTED 1f984: eb00edeb bl 5b138 <__umodsi3> <== NOT EXECUTED 1f988: e0600004 rsb r0, r0, r4 <== NOT EXECUTED 1f98c: e58d0244 str r0, [sp, #580] ; 0x244 <== NOT EXECUTED 1f990: e1a00280 lsl r0, r0, #5 <== NOT EXECUTED
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
1f994: e249c001 sub ip, r9, #1 <== NOT EXECUTED 1f998: e08c0000 add r0, ip, r0 <== NOT EXECUTED 1f99c: e1a01009 mov r1, r9 <== NOT EXECUTED 1f9a0: e58dc018 str ip, [sp, #24] <== NOT EXECUTED 1f9a4: eb00ed4f bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
1f9a8: e59d2230 ldr r2, [sp, #560] ; 0x230 <== NOT EXECUTED
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
1f9ac: e1a03000 mov r3, r0 <== NOT EXECUTED
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
1f9b0: e59d0234 ldr r0, [sp, #564] ; 0x234 <== NOT EXECUTED 1f9b4: e0602002 rsb r2, r0, r2 <== NOT EXECUTED 1f9b8: e58d0028 str r0, [sp, #40] ; 0x28 <== NOT EXECUTED
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
1f9bc: e1a01009 mov r1, r9 <== NOT EXECUTED
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
1f9c0: e0632002 rsb r2, r3, r2 <== NOT EXECUTED
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
1f9c4: e3a00902 mov r0, #32768 ; 0x8000 <== NOT EXECUTED
(((fmt_params->files_per_root_dir * FAT_DIRENTRY_SIZE)
+ fmt_params->bytes_per_sector - 1)
/ fmt_params->bytes_per_sector);
}
if (ret_val == 0) {
fatdata_sect_cnt = (fmt_params->totl_sector_cnt -
1f9c8: e58d2024 str r2, [sp, #36] ; 0x24 <== NOT EXECUTED
FAT_DIRENTRY_SIZE-1));
fmt_params->files_per_root_dir -= (fmt_params->files_per_root_dir %
(2*fmt_params->bytes_per_sector
/FAT_DIRENTRY_SIZE));
}
fmt_params->root_dir_sectors =
1f9cc: e58d3248 str r3, [sp, #584] ; 0x248 <== NOT EXECUTED
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
1f9d0: eb00ed44 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
/*
* check values to get legal arrangement of FAT type and cluster count
*/
ret_val = msdos_format_eval_sectors_per_cluster
1f9d4: e59d4238 ldr r4, [sp, #568] ; 0x238 <== NOT EXECUTED
(fmt_params->fattype,
fmt_params->bytes_per_sector,
fatdata_sect_cnt,
fmt_params->fat_num,
1f9d8: e5dd125c ldrb r1, [sp, #604] ; 0x25c <== NOT EXECUTED
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
1f9dc: e1540000 cmp r4, r0 <== NOT EXECUTED
ret_val = msdos_format_eval_sectors_per_cluster
(fmt_params->fattype,
fmt_params->bytes_per_sector,
fatdata_sect_cnt,
fmt_params->fat_num,
1f9e0: e58d100c str r1, [sp, #12] <== NOT EXECUTED
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
1f9e4: 9a000002 bls 1f9f4 <msdos_format+0x790> <== NOT EXECUTED
sectors_per_cluster /= 2;
1f9e8: e1a040a4 lsr r4, r4, #1 <== NOT EXECUTED
uint32_t sectors_per_fat;
uint32_t data_cluster_cnt;
/*
* ensure, that maximum cluster size (32KByte) is not exceeded
*/
while (MS_BYTES_PER_CLUSTER_LIMIT / bytes_per_sector < sectors_per_cluster) {
1f9ec: e1540000 cmp r4, r0 <== NOT EXECUTED 1f9f0: 8afffffc bhi 1f9e8 <msdos_format+0x784> <== NOT EXECUTED
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
1f9f4: e3a00eff mov r0, #4080 ; 0xff0 <== NOT EXECUTED 1f9f8: e3a0b801 mov fp, #65536 ; 0x10000 <== NOT EXECUTED 1f9fc: e2800005 add r0, r0, #5 <== NOT EXECUTED 1fa00: e24bb00b sub fp, fp, #11 <== NOT EXECUTED 1fa04: e58d0010 str r0, [sp, #16] <== NOT EXECUTED 1fa08: e58db01c str fp, [sp, #28] <== NOT EXECUTED
* compute number of data clusters for current data:
* - compute cluster count for data AND fat
* - compute storage size for FAT
* - subtract from total cluster count
*/
fatdata_cluster_cnt = fatdata_sec_cnt/sectors_per_cluster;
1fa0c: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED 1fa10: e1a01004 mov r1, r4 <== NOT EXECUTED 1fa14: eb00ed33 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
if (fattype == FAT_FAT12) {
1fa18: e35a0001 cmp sl, #1 <== NOT EXECUTED
* compute number of data clusters for current data:
* - compute cluster count for data AND fat
* - compute storage size for FAT
* - subtract from total cluster count
*/
fatdata_cluster_cnt = fatdata_sec_cnt/sectors_per_cluster;
1fa1c: e1a08000 mov r8, r0 <== NOT EXECUTED
if (fattype == FAT_FAT12) {
1fa20: 0a000075 beq 1fbfc <msdos_format+0x998> <== NOT EXECUTED
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
1fa24: e35a0002 cmp sl, #2 <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
1fa28: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED
fatdata_cluster_cnt = fatdata_sec_cnt/sectors_per_cluster;
if (fattype == FAT_FAT12) {
fat_capacity = fatdata_cluster_cnt * 3 / 2;
}
else if (fattype == FAT_FAT16) {
fat_capacity = fatdata_cluster_cnt * 2;
1fa2c: 01a00080 lsleq r0, r0, #1 <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
1fa30: 11a00108 lslne r0, r8, #2 <== NOT EXECUTED
}
sectors_per_fat = ((fat_capacity
1fa34: e0810000 add r0, r1, r0 <== NOT EXECUTED 1fa38: e1a01009 mov r1, r9 <== NOT EXECUTED 1fa3c: eb00ed29 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
1fa40: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
1fa44: e1a0b000 mov fp, r0 <== NOT EXECUTED
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
1fa48: e2440001 sub r0, r4, #1 <== NOT EXECUTED 1fa4c: e0200b92 mla r0, r2, fp, r0 <== NOT EXECUTED 1fa50: e1a01004 mov r1, r4 <== NOT EXECUTED 1fa54: eb00ed23 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 1fa58: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED 1fa5c: e0600008 rsb r0, r0, r8 <== NOT EXECUTED 1fa60: e150000c cmp r0, ip <== NOT EXECUTED 1fa64: 93a03000 movls r3, #0 <== NOT EXECUTED 1fa68: 83a03001 movhi r3, #1 <== NOT EXECUTED 1fa6c: e35a0002 cmp sl, #2 <== NOT EXECUTED 1fa70: 13a03000 movne r3, #0 <== NOT EXECUTED 1fa74: e3530000 cmp r3, #0 <== NOT EXECUTED 1fa78: 0a00006e beq 1fc38 <msdos_format+0x9d4> <== NOT EXECUTED
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
1fa7c: e1a04084 lsl r4, r4, #1 <== NOT EXECUTED
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if ((sectors_per_cluster * bytes_per_sector)
1fa80: e0030499 mul r3, r9, r4 <== NOT EXECUTED 1fa84: e3530902 cmp r3, #32768 ; 0x8000 <== NOT EXECUTED
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
1fa88: e3a02000 mov r2, #0 <== NOT EXECUTED
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if ((sectors_per_cluster * bytes_per_sector)
1fa8c: 9a00006d bls 1fc48 <msdos_format+0x9e4> <== NOT EXECUTED
finished = true;
}
} while (!finished);
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
1fa90: eb008d56 bl 42ff0 <__errno> <== NOT EXECUTED 1fa94: e3a03016 mov r3, #22 <== NOT EXECUTED 1fa98: e5803000 str r3, [r0] <== NOT EXECUTED 1fa9c: e59d0234 ldr r0, [sp, #564] ; 0x234 <== NOT EXECUTED 1faa0: e5dd125c ldrb r1, [sp, #604] ; 0x25c <== NOT EXECUTED
fatdata_sect_cnt,
fmt_params->fat_num,
fmt_params->sectors_per_cluster,
§ors_per_cluster_adj,
&(fmt_params->sectors_per_fat));
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
1faa4: e3a03000 mov r3, #0 <== NOT EXECUTED 1faa8: e3e0c000 mvn ip, #0 <== NOT EXECUTED 1faac: e58d3238 str r3, [sp, #568] ; 0x238 <== NOT EXECUTED 1fab0: e58dc014 str ip, [sp, #20] <== NOT EXECUTED 1fab4: e58d0028 str r0, [sp, #40] ; 0x28 <== NOT EXECUTED 1fab8: e58d100c str r1, [sp, #12] <== NOT EXECUTED
}
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
1fabc: e59d3248 ldr r3, [sp, #584] ; 0x248 <== NOT EXECUTED 1fac0: e3530000 cmp r3, #0 <== NOT EXECUTED 1fac4: 0a000083 beq 1fcd8 <msdos_format+0xa74> <== NOT EXECUTED
fmt_params->root_dir_start_sec =
1fac8: e59d123c ldr r1, [sp, #572] ; 0x23c <== NOT EXECUTED 1facc: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 1fad0: e59d0028 ldr r0, [sp, #40] ; 0x28 <== NOT EXECUTED 1fad4: e0220291 mla r2, r1, r2, r0 <== NOT EXECUTED
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
fmt_params->root_dir_fmt_sec_cnt = fmt_params->root_dir_sectors;
1fad8: e58d3250 str r3, [sp, #592] ; 0x250 <== NOT EXECUTED
/*
* determine location and size of root directory
* for formatting
*/
if (fmt_params->root_dir_sectors > 0) {
fmt_params->root_dir_start_sec =
1fadc: e58d224c str r2, [sp, #588] ; 0x24c <== NOT EXECUTED
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
}
/*
* determine usable OEMName
*/
if (ret_val == 0) {
1fae0: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 1fae4: e3520000 cmp r2, #0 <== NOT EXECUTED 1fae8: 1a000075 bne 1fcc4 <msdos_format+0xa60> <== NOT EXECUTED
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
1faec: e3550000 cmp r5, #0 <== NOT EXECUTED 1faf0: 059f15b4 ldreq r1, [pc, #1460] ; 200ac <msdos_format+0xe48><== NOT EXECUTED 1faf4: 0a000003 beq 1fb08 <msdos_format+0x8a4> <== NOT EXECUTED
(rqdata->OEMName != NULL)) {
1faf8: e5951000 ldr r1, [r5] <== NOT EXECUTED
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
1fafc: e59f35a8 ldr r3, [pc, #1448] ; 200ac <msdos_format+0xe48> <== NOT EXECUTED 1fb00: e3510000 cmp r1, #0 <== NOT EXECUTED 1fb04: 01a01003 moveq r1, r3 <== NOT EXECUTED 1fb08: e59f35a0 ldr r3, [pc, #1440] ; 200b0 <msdos_format+0xe4c> <== NOT EXECUTED 1fb0c: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 1fb10: e5930000 ldr r0, [r3] <== NOT EXECUTED
}
/*=========================================================================*\
| Function: |
\*-------------------------------------------------------------------------*/
int msdos_format
1fb14: e28c403c add r4, ip, #60 ; 0x3c <== NOT EXECUTED
if (ret_val == 0) {
const char *from;
char *to = fmt_params->OEMName;
int cnt;
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
1fb18: e28c3034 add r3, ip, #52 ; 0x34 <== NOT EXECUTED
/* * non-printable character in given name, so keep stuck * at that character and replace all following characters * with a ' ' */ *to++=' ';
1fb1c: e3a08020 mov r8, #32 <== NOT EXECUTED
}
*to = '\0';
1fb20: e3a0e000 mov lr, #0 <== NOT EXECUTED
from = rqdata->OEMName;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
1fb24: e5d12000 ldrb r2, [r1] <== NOT EXECUTED 1fb28: e080c002 add ip, r0, r2 <== NOT EXECUTED 1fb2c: e5dcc001 ldrb ip, [ip, #1] <== NOT EXECUTED 1fb30: e31c0097 tst ip, #151 ; 0x97 <== NOT EXECUTED
*to++ = *from++;
1fb34: 15432001 strbne r2, [r3, #-1] <== NOT EXECUTED
/* * non-printable character in given name, so keep stuck * at that character and replace all following characters * with a ' ' */ *to++=' ';
1fb38: 05438001 strbeq r8, [r3, #-1] <== NOT EXECUTED
}
*to = '\0';
1fb3c: e4c3e001 strb lr, [r3], #1 <== NOT EXECUTED
}
for (cnt = 0;
cnt < (sizeof(fmt_params->OEMName)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
*to++ = *from++;
1fb40: 12811001 addne r1, r1, #1 <== NOT EXECUTED
from = "RTEMS"; /* default: make "from" point to OS Name */
if ((rqdata != NULL) &&
(rqdata->OEMName != NULL)) {
from = rqdata->OEMName;
}
for (cnt = 0;
1fb44: e1530004 cmp r3, r4 <== NOT EXECUTED 1fb48: 1afffff5 bne 1fb24 <msdos_format+0x8c0> <== NOT EXECUTED
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
if ((rqdata != NULL) &&
1fb4c: e3550000 cmp r5, #0 <== NOT EXECUTED 1fb50: 0a0000be beq 1fe50 <msdos_format+0xbec> <== NOT EXECUTED
(rqdata->VolLabel != NULL)) {
1fb54: e5951004 ldr r1, [r5, #4] <== NOT EXECUTED
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
if ((rqdata != NULL) &&
1fb58: e3510000 cmp r1, #0 <== NOT EXECUTED
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
1fb5c: 13a03001 movne r3, #1 <== NOT EXECUTED 1fb60: 15cd3274 strbne r3, [sp, #628] ; 0x274 <== NOT EXECUTED
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
if ((rqdata != NULL) &&
1fb64: 0a0000b9 beq 1fe50 <msdos_format+0xbec> <== NOT EXECUTED
}
/*=========================================================================*\
| Function: |
\*-------------------------------------------------------------------------*/
int msdos_format
1fb68: e59d2020 ldr r2, [sp, #32] <== NOT EXECUTED
/* * non-printable character in given name, so keep stuck * at that character and replace all following characters * with a ' ' */ *to++=' ';
1fb6c: e3a08020 mov r8, #32 <== NOT EXECUTED
}
/*=========================================================================*\
| Function: |
\*-------------------------------------------------------------------------*/
int msdos_format
1fb70: e2824048 add r4, r2, #72 ; 0x48 <== NOT EXECUTED
int cnt;
from = ""; /* default: make "from" point to empty string */
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
1fb74: e282303d add r3, r2, #61 ; 0x3d <== NOT EXECUTED
* at that character and replace all following characters
* with a ' '
*/
*to++=' ';
}
*to = '\0';
1fb78: e3a0e000 mov lr, #0 <== NOT EXECUTED
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
1fb7c: e5d12000 ldrb r2, [r1] <== NOT EXECUTED 1fb80: e080c002 add ip, r0, r2 <== NOT EXECUTED 1fb84: e5dcc001 ldrb ip, [ip, #1] <== NOT EXECUTED 1fb88: e31c0097 tst ip, #151 ; 0x97 <== NOT EXECUTED
*to++ = *from++;
1fb8c: 15432001 strbne r2, [r3, #-1] <== NOT EXECUTED
/* * non-printable character in given name, so keep stuck * at that character and replace all following characters * with a ' ' */ *to++=' ';
1fb90: 05438001 strbeq r8, [r3, #-1] <== NOT EXECUTED
}
*to = '\0';
1fb94: e4c3e001 strb lr, [r3], #1 <== NOT EXECUTED
}
for (cnt = 0;
cnt < (sizeof(fmt_params->VolLabel)-1);
cnt++) {
if (isprint((unsigned char)*from)) {
*to++ = *from++;
1fb98: 12811001 addne r1, r1, #1 <== NOT EXECUTED
if ((rqdata != NULL) &&
(rqdata->VolLabel != NULL)) {
from = rqdata->VolLabel;
fmt_params->VolLabel_present = true;
}
for (cnt = 0;
1fb9c: e1530004 cmp r3, r4 <== NOT EXECUTED 1fba0: 1afffff5 bne 1fb7c <msdos_format+0x918> <== NOT EXECUTED
{
int ret_val = 0;
int rc;
struct timeval time_value;
rc = rtems_clock_get_tod_timeval(&time_value);
1fba4: e28d0fb1 add r0, sp, #708 ; 0x2c4 <== NOT EXECUTED 1fba8: ebffb06e bl bd68 <rtems_clock_get_tod_timeval> <== NOT EXECUTED
if (rc == RTEMS_SUCCESSFUL) {
1fbac: e3500000 cmp r0, #0 <== NOT EXECUTED 1fbb0: 1a0000ca bne 1fee0 <msdos_format+0xc7c> <== NOT EXECUTED
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
1fbb4: e59d32c4 ldr r3, [sp, #708] ; 0x2c4 <== NOT EXECUTED 1fbb8: e1a03083 lsl r3, r3, #1 <== NOT EXECUTED 1fbbc: e58d3278 str r3, [sp, #632] ; 0x278 <== NOT EXECUTED
ret_val = msdos_format_determine_fmt_params(dd,rqdata,&fmt_params);
}
/*
* if requested, write whole disk/partition with 0xe5
*/
if ((ret_val == 0) &&
1fbc0: e3550000 cmp r5, #0 <== NOT EXECUTED 1fbc4: 0afffe21 beq 1f450 <msdos_format+0x1ec> <== NOT EXECUTED
(rqdata != NULL) &&
!(rqdata->quick_format)) {
1fbc8: e5d52016 ldrb r2, [r5, #22] <== NOT EXECUTED 1fbcc: e3520000 cmp r2, #0 <== NOT EXECUTED 1fbd0: 1afffe1e bne 1f450 <msdos_format+0x1ec> <== NOT EXECUTED
ret_val = msdos_format_fill_sectors
1fbd4: e59dc22c ldr ip, [sp, #556] ; 0x22c <== NOT EXECUTED 1fbd8: e59d3230 ldr r3, [sp, #560] ; 0x230 <== NOT EXECUTED 1fbdc: e58dc000 str ip, [sp] <== NOT EXECUTED 1fbe0: e1a00005 mov r0, r5 <== NOT EXECUTED 1fbe4: e3a0c0e5 mov ip, #229 ; 0xe5 <== NOT EXECUTED 1fbe8: e1a01006 mov r1, r6 <== NOT EXECUTED 1fbec: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 1fbf0: ebfffd39 bl 1f0dc <msdos_format_fill_sectors> <== NOT EXECUTED 1fbf4: e1a04000 mov r4, r0 <== NOT EXECUTED 1fbf8: eafffdb6 b 1f2d8 <msdos_format+0x74> <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
1fbfc: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED 1fc00: e0800080 add r0, r0, r0, lsl #1 <== NOT EXECUTED 1fc04: e08100a0 add r0, r1, r0, lsr #1 <== NOT EXECUTED 1fc08: e1a01009 mov r1, r9 <== NOT EXECUTED 1fc0c: eb00ecb5 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
1fc10: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
}
else { /* FAT32 */
fat_capacity = fatdata_cluster_cnt * 4;
}
sectors_per_fat = ((fat_capacity
1fc14: e1a0b000 mov fp, r0 <== NOT EXECUTED
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
1fc18: e2440001 sub r0, r4, #1 <== NOT EXECUTED 1fc1c: e0200b92 mla r0, r2, fp, r0 <== NOT EXECUTED 1fc20: e1a01004 mov r1, r4 <== NOT EXECUTED 1fc24: eb00ecaf bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 1fc28: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 1fc2c: e0600008 rsb r0, r0, r8 <== NOT EXECUTED 1fc30: e1500003 cmp r0, r3 <== NOT EXECUTED 1fc34: 8affff90 bhi 1fa7c <msdos_format+0x818> <== NOT EXECUTED
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if ((sectors_per_cluster * bytes_per_sector)
1fc38: e0030499 mul r3, r9, r4 <== NOT EXECUTED 1fc3c: e3530902 cmp r3, #32768 ; 0x8000 <== NOT EXECUTED
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
((fattype == FAT_FAT16) && (data_cluster_cnt > FAT_FAT16_MAX_CLN))) {
sectors_per_cluster *= 2;
1fc40: e3a02001 mov r2, #1 <== NOT EXECUTED
finished = true;
}
/*
* when maximum cluster size is exceeded, we have invalid data, abort...
*/
if ((sectors_per_cluster * bytes_per_sector)
1fc44: 8affff91 bhi 1fa90 <msdos_format+0x82c> <== NOT EXECUTED
> MS_BYTES_PER_CLUSTER_LIMIT) {
ret_val = EINVAL;
finished = true;
}
} while (!finished);
1fc48: e3520000 cmp r2, #0 <== NOT EXECUTED 1fc4c: 0affff6e beq 1fa0c <msdos_format+0x7a8> <== NOT EXECUTED
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
1fc50: e3550000 cmp r5, #0 <== NOT EXECUTED
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
}
else {
*sectors_per_cluster_adj = sectors_per_cluster;
*sectors_per_fat_ptr = sectors_per_fat;
1fc54: e58db23c str fp, [sp, #572] ; 0x23c <== NOT EXECUTED
fatdata_sect_cnt,
fmt_params->fat_num,
fmt_params->sectors_per_cluster,
§ors_per_cluster_adj,
&(fmt_params->sectors_per_fat));
fmt_params->sectors_per_cluster = sectors_per_cluster_adj;
1fc58: e58d4238 str r4, [sp, #568] ; 0x238 <== NOT EXECUTED
/*
* determine media code
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
1fc5c: 0a000102 beq 2006c <msdos_format+0xe08> <== NOT EXECUTED 1fc60: e5d54015 ldrb r4, [r5, #21] <== NOT EXECUTED 1fc64: e3540000 cmp r4, #0 <== NOT EXECUTED 1fc68: 0a0000ff beq 2006c <msdos_format+0xe08> <== NOT EXECUTED
(rqdata->media != 0)) {
const char valid_media_codes[] =
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
1fc6c: e59f3440 ldr r3, [pc, #1088] ; 200b4 <msdos_format+0xe50> <== NOT EXECUTED
1fc70: e8930007 ldm r3, {r0, r1, r2} <== NOT EXECUTED
1fc74: e28d3fb1 add r3, sp, #708 ; 0x2c4 <== NOT EXECUTED
1fc78: e8a30003 stmia r3!, {r0, r1} <== NOT EXECUTED
if (NULL==memchr(valid_media_codes,
1fc7c: e28d0fb1 add r0, sp, #708 ; 0x2c4 <== NOT EXECUTED
*/
if (ret_val == 0) {
if ((rqdata != NULL) &&
(rqdata->media != 0)) {
const char valid_media_codes[] =
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
1fc80: e5c32000 strb r2, [r3] <== NOT EXECUTED
if (NULL==memchr(valid_media_codes,
1fc84: e1a01004 mov r1, r4 <== NOT EXECUTED 1fc88: e3a02009 mov r2, #9 <== NOT EXECUTED 1fc8c: eb009928 bl 46134 <memchr> <== NOT EXECUTED 1fc90: e3500000 cmp r0, #0 <== NOT EXECUTED
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
}
else {
fmt_params->media_code = rqdata->media;
1fc94: 15cd425d strbne r4, [sp, #605] ; 0x25d <== NOT EXECUTED
if (ret_val == 0) {
if ((rqdata != NULL) &&
(rqdata->media != 0)) {
const char valid_media_codes[] =
{0xF0,0xF8,0xF9,0xFA,0xFB,0xFC,0xFD,0xFE,0xFF};
if (NULL==memchr(valid_media_codes,
1fc98: 1affff87 bne 1fabc <msdos_format+0x858> <== NOT EXECUTED
rqdata->media,
sizeof(valid_media_codes))) {
ret_val = -1;
errno = EINVAL;
1fc9c: eb008cd3 bl 42ff0 <__errno> <== NOT EXECUTED 1fca0: e3a03016 mov r3, #22 <== NOT EXECUTED 1fca4: e5803000 str r3, [r0] <== NOT EXECUTED 1fca8: e3e02000 mvn r2, #0 <== NOT EXECUTED 1fcac: e59d3234 ldr r3, [sp, #564] ; 0x234 <== NOT EXECUTED 1fcb0: e5ddc25c ldrb ip, [sp, #604] ; 0x25c <== NOT EXECUTED 1fcb4: e58d2014 str r2, [sp, #20] <== NOT EXECUTED 1fcb8: e58d3028 str r3, [sp, #40] ; 0x28 <== NOT EXECUTED 1fcbc: e58dc00c str ip, [sp, #12] <== NOT EXECUTED 1fcc0: eaffff7d b 1fabc <msdos_format+0x858> <== NOT EXECUTED
}
/*
* Phuuu.... That's it.
*/
if (ret_val != 0) {
rtems_set_errno_and_return_minus_one(ret_val);
1fcc4: eb008cc9 bl 42ff0 <__errno> <== NOT EXECUTED 1fcc8: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 1fccc: e3e04000 mvn r4, #0 <== NOT EXECUTED 1fcd0: e5803000 str r3, [r0] <== NOT EXECUTED 1fcd4: eafffd81 b 1f2e0 <msdos_format+0x7c> <== NOT EXECUTED
}
else {
/*
* for FAT32: root directory is in cluster 2
*/
fmt_params->root_dir_start_sec =
1fcd8: e59d223c ldr r2, [sp, #572] ; 0x23c <== NOT EXECUTED 1fcdc: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 1fce0: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED 1fce4: e0231392 mla r3, r2, r3, r1 <== NOT EXECUTED 1fce8: e58d324c str r3, [sp, #588] ; 0x24c <== NOT EXECUTED
fmt_params->rsvd_sector_cnt
+ (fmt_params-> fat_num*fmt_params->sectors_per_fat);
fmt_params->root_dir_fmt_sec_cnt = fmt_params->sectors_per_cluster;
1fcec: e59d3238 ldr r3, [sp, #568] ; 0x238 <== NOT EXECUTED 1fcf0: e58d3250 str r3, [sp, #592] ; 0x250 <== NOT EXECUTED 1fcf4: eaffff79 b 1fae0 <msdos_format+0x87c> <== NOT EXECUTED 1fcf8: e59d1234 ldr r1, [sp, #564] ; 0x234 <== NOT EXECUTED 1fcfc: e5dd225c ldrb r2, [sp, #604] ; 0x25c <== NOT EXECUTED 1fd00: e58d1028 str r1, [sp, #40] ; 0x28 <== NOT EXECUTED 1fd04: e58d200c str r2, [sp, #12] <== NOT EXECUTED 1fd08: eaffff6b b 1fabc <msdos_format+0x858> <== NOT EXECUTED
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
1fd0c: e3a0c002 mov ip, #2 <== NOT EXECUTED
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1fd10: e1a0100c mov r1, ip <== NOT EXECUTED 1fd14: e1a00005 mov r0, r5 <== NOT EXECUTED 1fd18: e59f2370 ldr r2, [pc, #880] ; 20090 <msdos_format+0xe2c> <== NOT EXECUTED 1fd1c: e1a0300c mov r3, ip <== NOT EXECUTED
* determine number of FATs
*/
if (ret_val == 0) {
if ((rqdata == NULL) ||
(rqdata->fat_num == 0)) {
fmt_params->fat_num = 2;
1fd20: e5cdc25c strb ip, [sp, #604] ; 0x25c <== NOT EXECUTED
ret_val = EINVAL;
}
}
if (ret_val == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1fd24: ebfffcc1 bl 1f030 <msdos_format_printf> <== NOT EXECUTED 1fd28: eafffdb7 b 1f40c <msdos_format+0x1a8> <== NOT EXECUTED
{
uint32_t total_sectors_num16 = 0;
uint32_t total_sectors_num32 = 0;
/* store total sector count in either 16 or 32 bit field in mbr */
if (fmt_params->totl_sector_cnt < 0x10000) {
1fd2c: e1a02423 lsr r2, r3, #8 <== NOT EXECUTED 1fd30: e3a0a000 mov sl, #0 <== NOT EXECUTED 1fd34: e20220ff and r2, r2, #255 ; 0xff <== NOT EXECUTED 1fd38: e20330ff and r3, r3, #255 ; 0xff <== NOT EXECUTED 1fd3c: e58d200c str r2, [sp, #12] <== NOT EXECUTED 1fd40: e58d301c str r3, [sp, #28] <== NOT EXECUTED 1fd44: e58da014 str sl, [sp, #20] <== NOT EXECUTED 1fd48: e58da018 str sl, [sp, #24] <== NOT EXECUTED 1fd4c: e58da010 str sl, [sp, #16] <== NOT EXECUTED 1fd50: eafffde4 b 1f4e8 <msdos_format+0x284> <== NOT EXECUTED
(rqdata->files_per_root_dir > 0)) {
fmt_params->files_per_root_dir = rqdata->files_per_root_dir;
}
else {
if (fmt_params->fattype == FAT_FAT16) {
fmt_params->files_per_root_dir = 512;
1fd54: e35a0002 cmp sl, #2 <== NOT EXECUTED 1fd58: e3a04f7f mov r4, #508 ; 0x1fc <== NOT EXECUTED 1fd5c: 02844003 addeq r4, r4, #3 <== NOT EXECUTED 1fd60: 13a0403f movne r4, #63 ; 0x3f <== NOT EXECUTED 1fd64: eaffff01 b 1f970 <msdos_format+0x70c> <== NOT EXECUTED
fmt_params->fattype = FAT_FAT32;
}
else if ((rqdata != NULL) &&
(rqdata->fattype != MSDOS_FMT_FATANY)) {
ret_val = -1;
errno = EINVAL;
1fd68: eb008ca0 bl 42ff0 <__errno> <== NOT EXECUTED 1fd6c: e3a03016 mov r3, #22 <== NOT EXECUTED 1fd70: e5803000 str r3, [r0] <== NOT EXECUTED 1fd74: e3e03000 mvn r3, #0 <== NOT EXECUTED 1fd78: e58d3014 str r3, [sp, #20] <== NOT EXECUTED 1fd7c: eafffec9 b 1f8a8 <msdos_format+0x644> <== NOT EXECUTED
\*=========================================================================*/
{
/*
* clear fsinfo sector data
*/
memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE);
1fd80: e28d402c add r4, sp, #44 ; 0x2c <== NOT EXECUTED 1fd84: e3a01000 mov r1, #0 <== NOT EXECUTED 1fd88: e3a02c02 mov r2, #512 ; 0x200 <== NOT EXECUTED 1fd8c: e1a00004 mov r0, r4 <== NOT EXECUTED 1fd90: eb0099cd bl 464cc <memset> <== NOT EXECUTED
}
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
(fmt_params.fsinfo_sec != 0)) {
1fd94: e59d1258 ldr r1, [sp, #600] ; 0x258 <== NOT EXECUTED
/* * write LEADSIG, STRUCTSIG, TRAILSIG */ FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE ); FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE); FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
1fd98: e3a08055 mov r8, #85 ; 0x55 <== NOT EXECUTED
/* * write "empty" values for free cluster count and next cluster number */ FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
1fd9c: e3e03000 mvn r3, #0 <== NOT EXECUTED
*/ memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE); /* * write LEADSIG, STRUCTSIG, TRAILSIG */ FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
1fda0: e3a0e052 mov lr, #82 ; 0x52 <== NOT EXECUTED 1fda4: e3a0c061 mov ip, #97 ; 0x61 <== NOT EXECUTED 1fda8: e3a00041 mov r0, #65 ; 0x41 <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
1fdac: e3a02072 mov r2, #114 ; 0x72 <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
1fdb0: e5cd822a strb r8, [sp, #554] ; 0x22a <== NOT EXECUTED
ret_val = msdos_format_gen_fsinfo(tmp_sec);
}
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
1fdb4: e3510000 cmp r1, #0 <== NOT EXECUTED
/* * write LEADSIG, STRUCTSIG, TRAILSIG */ FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE ); FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE); FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
1fdb8: e3e08055 mvn r8, #85 ; 0x55 <== NOT EXECUTED
*/ memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE); /* * write LEADSIG, STRUCTSIG, TRAILSIG */ FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
1fdbc: e5cde02d strb lr, [sp, #45] ; 0x2d <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
1fdc0: e5cd2211 strb r2, [sp, #529] ; 0x211 <== NOT EXECUTED 1fdc4: e5cd0212 strb r0, [sp, #530] ; 0x212 <== NOT EXECUTED 1fdc8: e5cdc213 strb ip, [sp, #531] ; 0x213 <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE);
1fdcc: e5cd822b strb r8, [sp, #555] ; 0x22b <== NOT EXECUTED
/* * write "empty" values for free cluster count and next cluster number */ FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO, 0xffffffff); FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
1fdd0: e5cd321b strb r3, [sp, #539] ; 0x21b <== NOT EXECUTED
*/ memset(fsinfo,0,FAT_TOTAL_FSINFO_SIZE); /* * write LEADSIG, STRUCTSIG, TRAILSIG */ FAT_SET_FSINFO_LEAD_SIGNATURE (fsinfo,FAT_FSINFO_LEAD_SIGNATURE_VALUE );
1fdd4: e5cde02c strb lr, [sp, #44] ; 0x2c <== NOT EXECUTED 1fdd8: e5cdc02e strb ip, [sp, #46] ; 0x2e <== NOT EXECUTED 1fddc: e5cd002f strb r0, [sp, #47] ; 0x2f <== NOT EXECUTED
FAT_SET_FSINFO_STRUC_SIGNATURE(fsinfo,FAT_FSINFO_STRUC_SIGNATURE_VALUE);
1fde0: e5cd2210 strb r2, [sp, #528] ; 0x210 <== NOT EXECUTED
FAT_SET_FSINFO_TRAIL_SIGNATURE(fsinfo,FAT_FSINFO_TRAIL_SIGNATURE_VALUE); /* * write "empty" values for free cluster count and next cluster number */ FAT_SET_FSINFO_FREE_CLUSTER_COUNT(fsinfo+FAT_FSI_INFO,
1fde4: e5cd3214 strb r3, [sp, #532] ; 0x214 <== NOT EXECUTED 1fde8: e5cd3215 strb r3, [sp, #533] ; 0x215 <== NOT EXECUTED 1fdec: e5cd3216 strb r3, [sp, #534] ; 0x216 <== NOT EXECUTED 1fdf0: e5cd3217 strb r3, [sp, #535] ; 0x217 <== NOT EXECUTED
0xffffffff); FAT_SET_FSINFO_NEXT_FREE_CLUSTER (fsinfo+FAT_FSI_INFO,
1fdf4: e5cd3218 strb r3, [sp, #536] ; 0x218 <== NOT EXECUTED 1fdf8: e5cd3219 strb r3, [sp, #537] ; 0x219 <== NOT EXECUTED 1fdfc: e5cd321a strb r3, [sp, #538] ; 0x21a <== NOT EXECUTED
ret_val = msdos_format_gen_fsinfo(tmp_sec);
}
/*
* write fsinfo sector
*/
if ((ret_val == 0) &&
1fe00: 0afffe2f beq 1f6c4 <msdos_format+0x460> <== NOT EXECUTED
(fmt_params.fsinfo_sec != 0)) {
ret_val = msdos_format_write_sec(fd,
1fe04: e1a03004 mov r3, r4 <== NOT EXECUTED 1fe08: e1a00006 mov r0, r6 <== NOT EXECUTED 1fe0c: e59d222c ldr r2, [sp, #556] ; 0x22c <== NOT EXECUTED 1fe10: ebfffc9d bl 1f08c <msdos_format_write_sec> <== NOT EXECUTED
}
/*
* write FAT as all empty
* -> write all FAT sectors as zero
*/
if (ret_val == 0) {
1fe14: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1fe18: 1afffd30 bne 1f2e0 <msdos_format+0x7c> <== NOT EXECUTED 1fe1c: eafffe28 b 1f6c4 <msdos_format+0x460> <== NOT EXECUTED
if ((ret_val == 0) &&
(fmt_params.mbr_copy_sec != 0)) {
/*
* write copy of MBR
*/
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1fe20: e3a01002 mov r1, #2 <== NOT EXECUTED 1fe24: e59f228c ldr r2, [pc, #652] ; 200b8 <msdos_format+0xe54> <== NOT EXECUTED 1fe28: e1a00005 mov r0, r5 <== NOT EXECUTED 1fe2c: ebfffc7f bl 1f030 <msdos_format_printf> <== NOT EXECUTED
"write back up MRB sector\n");
ret_val = msdos_format_write_sec(fd,
1fe30: e1a00006 mov r0, r6 <== NOT EXECUTED 1fe34: e1a03008 mov r3, r8 <== NOT EXECUTED 1fe38: e59d1254 ldr r1, [sp, #596] ; 0x254 <== NOT EXECUTED 1fe3c: e59d222c ldr r2, [sp, #556] ; 0x22c <== NOT EXECUTED 1fe40: ebfffc91 bl 1f08c <msdos_format_write_sec> <== NOT EXECUTED
}
}
/*
* for FAT32: initialize info sector on disk
*/
if ((ret_val == 0) &&
1fe44: e2504000 subs r4, r0, #0 <== NOT EXECUTED 1fe48: 0afffe1a beq 1f6b8 <msdos_format+0x454> <== NOT EXECUTED 1fe4c: eafffd23 b 1f2e0 <msdos_format+0x7c> <== NOT EXECUTED
if (ret_val == 0) {
const char *from;
char *to = fmt_params->VolLabel;
int cnt;
from = ""; /* default: make "from" point to empty string */
if ((rqdata != NULL) &&
1fe50: e59f1264 ldr r1, [pc, #612] ; 200bc <msdos_format+0xe58> <== NOT EXECUTED 1fe54: eaffff43 b 1fb68 <msdos_format+0x904> <== NOT EXECUTED
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
1fe58: e5dd225d ldrb r2, [sp, #605] ; 0x25d <== NOT EXECUTED 1fe5c: e1e02c02 mvn r2, r2, lsl #24 <== NOT EXECUTED 1fe60: e1e02c22 mvn r2, r2, lsr #24 <== NOT EXECUTED 1fe64: e1a01c22 lsr r1, r2, #24 <== NOT EXECUTED 1fe68: e5cd102d strb r1, [sp, #45] ; 0x2d <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
1fe6c: e3e01007 mvn r1, #7 <== NOT EXECUTED
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
1fe70: e3e03000 mvn r3, #0 <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
1fe74: e5cd1030 strb r1, [sp, #48] ; 0x30 <== NOT EXECUTED 1fe78: e3a0100f mov r1, #15 <== NOT EXECUTED 1fe7c: e5cd3032 strb r3, [sp, #50] ; 0x32 <== NOT EXECUTED 1fe80: e5cd1033 strb r1, [sp, #51] ; 0x33 <== NOT EXECUTED
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
break;
case FAT_FAT32:
/* FAT entry 0: 0xffffff00|media_type */
FAT_SET_VAL32(tmp_sec,0,0xffffff00|fmt_params.media_code);
1fe84: e5cd202c strb r2, [sp, #44] ; 0x2c <== NOT EXECUTED 1fe88: e5cd302e strb r3, [sp, #46] ; 0x2e <== NOT EXECUTED 1fe8c: e5cd302f strb r3, [sp, #47] ; 0x2f <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL32(tmp_sec,4,FAT_FAT32_EOC);
1fe90: e5cd3031 strb r3, [sp, #49] ; 0x31 <== NOT EXECUTED 1fe94: eafffe4f b 1f7d8 <msdos_format+0x574> <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL16(tmp_sec,0,0xff00|fmt_params.media_code);
1fe98: e5dd225d ldrb r2, [sp, #605] ; 0x25d <== NOT EXECUTED 1fe9c: e3e03000 mvn r3, #0 <== NOT EXECUTED 1fea0: e5cd202c strb r2, [sp, #44] ; 0x2c <== NOT EXECUTED
/* FAT entry 1: EOC */
FAT_SET_VAL16(tmp_sec,2,FAT_FAT16_EOC);
1fea4: e3e02007 mvn r2, #7 <== NOT EXECUTED 1fea8: e5cd202e strb r2, [sp, #46] ; 0x2e <== NOT EXECUTED 1feac: e5cd302f strb r3, [sp, #47] ; 0x2f <== NOT EXECUTED
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
break;
case FAT_FAT16:
/* FAT entry 0: 0xff00|media_type */
FAT_SET_VAL16(tmp_sec,0,0xff00|fmt_params.media_code);
1feb0: e5cd302d strb r3, [sp, #45] ; 0x2d <== NOT EXECUTED
+ (sectors_per_cluster - 1))
/ sectors_per_cluster));
/*
* data cluster count too big? then make sectors bigger
*/
if (((fattype == FAT_FAT12) && (data_cluster_cnt > FAT_FAT12_MAX_CLN)) ||
1feb4: e5dd325c ldrb r3, [sp, #604] ; 0x25c <== NOT EXECUTED 1feb8: e2533000 subs r3, r3, #0 <== NOT EXECUTED 1febc: 13a03001 movne r3, #1 <== NOT EXECUTED 1fec0: eafffe50 b 1f808 <msdos_format+0x5a4> <== NOT EXECUTED
memset(tmp_sec,0,sizeof(tmp_sec));
switch(fmt_params.fattype) {
case FAT_FAT12:
/* LSBits of FAT entry 0: media_type */
FAT_SET_VAL8(tmp_sec,0,(fmt_params.media_code));
1fec4: e5dd325d ldrb r3, [sp, #605] ; 0x25d <== NOT EXECUTED 1fec8: e5cd302c strb r3, [sp, #44] ; 0x2c <== NOT EXECUTED
/* MSBits of FAT entry 0:0xf, LSBits of FAT entry 1: LSB of EOC */
FAT_SET_VAL8(tmp_sec,1,(0x0f | (FAT_FAT12_EOC << 4)));
1fecc: e3e03070 mvn r3, #112 ; 0x70 <== NOT EXECUTED 1fed0: e5cd302d strb r3, [sp, #45] ; 0x2d <== NOT EXECUTED
/* MSBits of FAT entry 1: MSBits of EOC */
FAT_SET_VAL8(tmp_sec,2,(FAT_FAT12_EOC >> 4));
1fed4: e3e03000 mvn r3, #0 <== NOT EXECUTED 1fed8: e5cd302e strb r3, [sp, #46] ; 0x2e <== NOT EXECUTED
break;
1fedc: eafffff4 b 1feb4 <msdos_format+0xc50> <== NOT EXECUTED
rc = rtems_clock_get_tod_timeval(&time_value);
if (rc == RTEMS_SUCCESSFUL) {
*volid_ptr = time_value.tv_sec + time_value.tv_sec;
}
else {
*volid_ptr = rand();
1fee0: eb00a0a4 bl 48178 <rand> <== NOT EXECUTED 1fee4: e58d0278 str r0, [sp, #632] ; 0x278 <== NOT EXECUTED 1fee8: eaffff34 b 1fbc0 <msdos_format+0x95c> <== NOT EXECUTED
< ((uint32_t)FAT_FAT12_MAX_CLN)*8) {
fmt_params->fattype = FAT_FAT12;
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt
1feec: e3e034ff mvn r3, #-16777216 ; 0xff000000 <== NOT EXECUTED 1fef0: e243360e sub r3, r3, #14680064 ; 0xe00000 <== NOT EXECUTED 1fef4: e2433e16 sub r3, r3, #352 ; 0x160 <== NOT EXECUTED 1fef8: e1520003 cmp r2, r3 <== NOT EXECUTED
< ((uint32_t)FAT_FAT16_MAX_CLN)*32) {
fmt_params->fattype = FAT_FAT16;
1fefc: 93a03002 movls r3, #2 <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
1ff00: 958d3238 strls r3, [sp, #568] ; 0x238 <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt
< ((uint32_t)FAT_FAT16_MAX_CLN)*32) {
fmt_params->fattype = FAT_FAT16;
1ff04: 95cd325e strbls r3, [sp, #606] ; 0x25e <== NOT EXECUTED
< ((uint32_t)FAT_FAT12_MAX_CLN)*8) {
fmt_params->fattype = FAT_FAT12;
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else if (fmt_params->totl_sector_cnt
1ff08: 9afffd48 bls 1f430 <msdos_format+0x1cc> <== NOT EXECUTED
/* start trying with small clusters */
fmt_params->sectors_per_cluster = 2;
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
1ff0c: e3a03101 mov r3, #1073741824 ; 0x40000000 <== NOT EXECUTED 1ff10: e0933008 adds r3, r3, r8 <== NOT EXECUTED 1ff14: e3a04000 mov r4, #0 <== NOT EXECUTED 1ff18: e1a00f23 lsr r0, r3, #30 <== NOT EXECUTED 1ff1c: e0a44009 adc r4, r4, r9 <== NOT EXECUTED 1ff20: e1800104 orr r0, r0, r4, lsl #2 <== NOT EXECUTED 1ff24: e3a0301f mov r3, #31 <== NOT EXECUTED
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
1ff28: e3a01001 mov r1, #1 <== NOT EXECUTED 1ff2c: ea000001 b 1ff38 <msdos_format+0xcd4> <== NOT EXECUTED
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
1ff30: e2533001 subs r3, r3, #1 <== NOT EXECUTED 1ff34: 0a00004a beq 20064 <msdos_format+0xe00> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
1ff38: e1a02311 lsl r2, r1, r3 <== NOT EXECUTED 1ff3c: e1120000 tst r2, r0 <== NOT EXECUTED 1ff40: 0afffffa beq 1ff30 <msdos_format+0xccc> <== NOT EXECUTED
}
else {
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
1ff44: e3a03004 mov r3, #4 <== NOT EXECUTED 1ff48: e5cd325e strb r3, [sp, #606] ; 0x25e <== NOT EXECUTED
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
break;
fmt_params->sectors_per_cluster = 1 << b;
1ff4c: e58d2238 str r2, [sp, #568] ; 0x238 <== NOT EXECUTED 1ff50: eafffd36 b 1f430 <msdos_format+0x1cc> <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
1ff54: e59de23c ldr lr, [sp, #572] ; 0x23c <== NOT EXECUTED 1ff58: e1a0c82e lsr ip, lr, #16 <== NOT EXECUTED 1ff5c: e5cdc052 strb ip, [sp, #82] ; 0x52 <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
1ff60: e3a0c002 mov ip, #2 <== NOT EXECUTED 1ff64: e5cdc058 strb ip, [sp, #88] ; 0x58 <== NOT EXECUTED
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
1ff68: e3a0c001 mov ip, #1 <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
1ff6c: e59d1254 ldr r1, [sp, #596] ; 0x254 <== NOT EXECUTED
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
1ff70: e5cdc05c strb ip, [sp, #92] ; 0x5c <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
1ff74: e3a0c029 mov ip, #41 ; 0x29 <== NOT EXECUTED 1ff78: e5cdc06e strb ip, [sp, #110] ; 0x6e <== NOT EXECUTED
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
1ff7c: e59dc254 ldr ip, [sp, #596] ; 0x254 <== NOT EXECUTED 1ff80: e1a0b421 lsr fp, r1, #8 <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
1ff84: e1a09c2e lsr r9, lr, #24 <== NOT EXECUTED 1ff88: e1a0a42e lsr sl, lr, #8 <== NOT EXECUTED 1ff8c: e5cda051 strb sl, [sp, #81] ; 0x51 <== NOT EXECUTED 1ff90: e5cd9053 strb r9, [sp, #83] ; 0x53 <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
1ff94: e5cdb05f strb fp, [sp, #95] ; 0x5f <== NOT EXECUTED
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
1ff98: e584803c str r8, [r4, #60] ; 0x3c <== NOT EXECUTED
? "FAT12 "
: "FAT16 ",
FAT_BR_FILSYSTYPE_SIZE);
}
else {
FAT_SET_BR_SECTORS_PER_FAT32(mbr ,fmt_params->sectors_per_fat);
1ff9c: e5cde050 strb lr, [sp, #80] ; 0x50 <== NOT EXECUTED
FAT_SET_BR_EXT_FLAGS(mbr , 0);
1ffa0: e5cd8054 strb r8, [sp, #84] ; 0x54 <== NOT EXECUTED 1ffa4: e5cd8055 strb r8, [sp, #85] ; 0x55 <== NOT EXECUTED
FAT_SET_BR_FSVER(mbr , 0); /* FAT32 Version:0.0 */
1ffa8: e5cd8056 strb r8, [sp, #86] ; 0x56 <== NOT EXECUTED 1ffac: e5cd8057 strb r8, [sp, #87] ; 0x57 <== NOT EXECUTED
FAT_SET_BR_FAT32_ROOT_CLUSTER(mbr , 2); /* put root dir to cluster 2 */
1ffb0: e5cd8059 strb r8, [sp, #89] ; 0x59 <== NOT EXECUTED 1ffb4: e5cd805a strb r8, [sp, #90] ; 0x5a <== NOT EXECUTED 1ffb8: e5cd805b strb r8, [sp, #91] ; 0x5b <== NOT EXECUTED
FAT_SET_BR_FAT32_FS_INFO_SECTOR(mbr, 1); /* Put fsinfo to rsrvd sec 1*/
1ffbc: e5cd805d strb r8, [sp, #93] ; 0x5d <== NOT EXECUTED
FAT_SET_BR_FAT32_BK_BOOT_SECTOR(mbr, fmt_params->mbr_copy_sec ); /* Put MBR copy to rsrvd sec */
1ffc0: e5cdc05e strb ip, [sp, #94] ; 0x5e <== NOT EXECUTED
memset(FAT_GET_ADDR_BR_FAT32_RESERVED(mbr),0,FAT_BR_FAT32_RESERVED_SIZE);
1ffc4: e5848034 str r8, [r4, #52] ; 0x34 <== NOT EXECUTED 1ffc8: e5848038 str r8, [r4, #56] ; 0x38 <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
1ffcc: e5cd806c strb r8, [sp, #108] ; 0x6c <== NOT EXECUTED
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
1ffd0: e5cd806d strb r8, [sp, #109] ; 0x6d <== NOT EXECUTED
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
1ffd4: e5cd806f strb r8, [sp, #111] ; 0x6f <== NOT EXECUTED 1ffd8: e5cd8070 strb r8, [sp, #112] ; 0x70 <== NOT EXECUTED 1ffdc: e5cd8071 strb r8, [sp, #113] ; 0x71 <== NOT EXECUTED 1ffe0: e5cd8072 strb r8, [sp, #114] ; 0x72 <== NOT EXECUTED
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
1ffe4: e5c48047 strb r8, [r4, #71] ; 0x47 <== NOT EXECUTED 1ffe8: e5c48048 strb r8, [r4, #72] ; 0x48 <== NOT EXECUTED 1ffec: e5c48049 strb r8, [r4, #73] ; 0x49 <== NOT EXECUTED 1fff0: e5c4804a strb r8, [r4, #74] ; 0x4a <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
1fff4: e2840052 add r0, r4, #82 ; 0x52 <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
1fff8: e5c4804b strb r8, [r4, #75] ; 0x4b <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
1fffc: e59f10bc ldr r1, [pc, #188] ; 200c0 <msdos_format+0xe5c> <== NOT EXECUTED 20000: e3a02008 mov r2, #8 <== NOT EXECUTED
FAT_SET_BR_FAT32_DRVNUM(mbr , 0); /* only needed for INT13... */
FAT_SET_BR_FAT32_RSVD1(mbr , 0); /* fill with zero */
FAT_SET_BR_FAT32_BOOTSIG(mbr ,FAT_BR_FAT32_BOOTSIG_VAL);
FAT_SET_BR_FAT32_VOLID(mbr , 0); /* not set */
memset(FAT_GET_ADDR_BR_FAT32_VOLLAB(mbr) ,0,FAT_BR_VOLLAB_SIZE);
20004: e5c4804c strb r8, [r4, #76] ; 0x4c <== NOT EXECUTED 20008: e5c48051 strb r8, [r4, #81] ; 0x51 <== NOT EXECUTED 2000c: e5c4804d strb r8, [r4, #77] ; 0x4d <== NOT EXECUTED 20010: e5c4804e strb r8, [r4, #78] ; 0x4e <== NOT EXECUTED 20014: e5c4804f strb r8, [r4, #79] ; 0x4f <== NOT EXECUTED 20018: e5c48050 strb r8, [r4, #80] ; 0x50 <== NOT EXECUTED
memcpy(FAT_GET_ADDR_BR_FAT32_FILSYSTYPE(mbr),
2001c: eb0098a3 bl 462b0 <memcpy> <== NOT EXECUTED 20020: eafffd8b b 1f654 <msdos_format+0x3f0> <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"sectors per cluster: %d\n", fmt_params->sectors_per_cluster);
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
20024: e3a03020 mov r3, #32 <== NOT EXECUTED 20028: e58d3234 str r3, [sp, #564] ; 0x234 <== NOT EXECUTED
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
2002c: e3a03006 mov r3, #6 <== NOT EXECUTED 20030: e58d3254 str r3, [sp, #596] ; 0x254 <== NOT EXECUTED
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
20034: e3a03001 mov r3, #1 <== NOT EXECUTED 20038: e58d3258 str r3, [sp, #600] ; 0x258 <== NOT EXECUTED
if (fmt_params->fattype == FAT_FAT32) {
/* recommended: for FAT32, always set reserved sector count to 32 */
fmt_params->rsvd_sector_cnt = 32;
/* for FAT32, always set files per root directory 0 */
fmt_params->files_per_root_dir = 0;
2003c: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 20040: e59d922c ldr r9, [sp, #556] ; 0x22c <== NOT EXECUTED 20044: e58d3244 str r3, [sp, #580] ; 0x244 <== NOT EXECUTED
/* location of copy of MBR */
fmt_params->mbr_copy_sec = 6;
/* location of fsinfo sector */
fmt_params->fsinfo_sec = 1;
20048: e1a00003 mov r0, r3 <== NOT EXECUTED 2004c: eafffe50 b 1f994 <msdos_format+0x730> <== NOT EXECUTED
/* check that device is registered as block device and lock it */
if (ret_val == 0) {
dd = rtems_disk_obtain(stat_buf.st_rdev);
if (dd == NULL) {
errno = ENOTTY;
20050: eb008be6 bl 42ff0 <__errno> <== NOT EXECUTED 20054: e3a03019 mov r3, #25 <== NOT EXECUTED 20058: e5803000 str r3, [r0] <== NOT EXECUTED 2005c: e3e04000 mvn r4, #0 <== NOT EXECUTED 20060: eafffc9b b 1f2d4 <msdos_format+0x70> <== NOT EXECUTED
#define ONE_GB (1024L * 1024L * 1024L)
uint32_t gigs = (total_size + ONE_GB) / ONE_GB;
int b;
fmt_params->fattype = FAT_FAT32;
/* scale with the size of disk... */
for (b = 31; b > 0; b--)
20064: e3a02001 mov r2, #1 <== NOT EXECUTED 20068: eaffffb5 b 1ff44 <msdos_format+0xce0> <== NOT EXECUTED
else {
fmt_params->media_code = rqdata->media;
}
}
else {
fmt_params->media_code = FAT_BR_MEDIA_FIXED;
2006c: e3e03007 mvn r3, #7 <== NOT EXECUTED 20070: e5cd325d strb r3, [sp, #605] ; 0x25d <== NOT EXECUTED 20074: eafffe90 b 1fabc <msdos_format+0x858> <== NOT EXECUTED
* check sectors per cluster.
* must be power of 2
* must be smaller than or equal to 128
* sectors_per_cluster*bytes_per_sector must not be bigger than 32K
*/
for (onebit = 128;onebit >= 1;onebit = onebit>>1) {
20078: e58d3238 str r3, [sp, #568] ; 0x238 <== NOT EXECUTED 2007c: eafffe28 b 1f924 <msdos_format+0x6c0> <== NOT EXECUTED
0001f0dc <msdos_format_fill_sectors>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
1f0dc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
1f0e0: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
1f0e4: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
1f0e8: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
1f0ec: e58d1000 str r1, [sp] <== NOT EXECUTED 1f0f0: e1a05002 mov r5, r2 <== NOT EXECUTED 1f0f4: e1a0a003 mov sl, r3 <== NOT EXECUTED 1f0f8: e5dd4030 ldrb r4, [sp, #48] ; 0x30 <== NOT EXECUTED
/*
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
1f0fc: ebffa4df bl 8480 <malloc> <== NOT EXECUTED
if (fill_buffer == NULL) {
1f100: e2509000 subs r9, r0, #0 <== NOT EXECUTED 1f104: 0a000039 beq 1f1f0 <msdos_format_fill_sectors+0x114> <== NOT EXECUTED
errno = ENOMEM;
ret_val = -1;
}
else {
memset(fill_buffer,fill_byte,sector_size);
1f108: e1a01004 mov r1, r4 <== NOT EXECUTED 1f10c: e59d202c ldr r2, [sp, #44] ; 0x2c <== NOT EXECUTED 1f110: eb009ced bl 464cc <memset> <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
1f114: e25a7000 subs r7, sl, #0 <== NOT EXECUTED 1f118: 13a07001 movne r7, #1 <== NOT EXECUTED
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f11c: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 1f120: e3a01002 mov r1, #2 <== NOT EXECUTED 1f124: e59f2128 ldr r2, [pc, #296] ; 1f254 <msdos_format_fill_sectors+0x178><== NOT EXECUTED 1f128: ebffffc0 bl 1f030 <msdos_format_printf> <== NOT EXECUTED
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
1f12c: e3570000 cmp r7, #0 <== NOT EXECUTED 1f130: 0a000042 beq 1f240 <msdos_format_fill_sectors+0x164> <== NOT EXECUTED 1f134: e08a610a add r6, sl, sl, lsl #2 <== NOT EXECUTED 1f138: e0866106 add r6, r6, r6, lsl #2 <== NOT EXECUTED 1f13c: e1a06106 lsl r6, r6, #2 <== NOT EXECUTED 1f140: e1a0800a mov r8, sl <== NOT EXECUTED 1f144: e3e0b000 mvn fp, #0 <== NOT EXECUTED 1f148: ea000010 b 1f190 <msdos_format_fill_sectors+0xb4> <== NOT EXECUTED
if (percent != last_percent) {
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
1f14c: e1a01005 mov r1, r5 <== NOT EXECUTED 1f150: e1a03009 mov r3, r9 <== NOT EXECUTED 1f154: e59d0000 ldr r0, [sp] <== NOT EXECUTED 1f158: e59d202c ldr r2, [sp, #44] ; 0x2c <== NOT EXECUTED 1f15c: ebffffca bl 1f08c <msdos_format_write_sec> <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
1f160: e2588001 subs r8, r8, #1 <== NOT EXECUTED 1f164: 03a03000 moveq r3, #0 <== NOT EXECUTED 1f168: 13a03001 movne r3, #1 <== NOT EXECUTED 1f16c: e3500000 cmp r0, #0 <== NOT EXECUTED 1f170: 13a03000 movne r3, #0 <== NOT EXECUTED 1f174: 02033001 andeq r3, r3, #1 <== NOT EXECUTED 1f178: e3530000 cmp r3, #0 <== NOT EXECUTED 1f17c: e1a07000 mov r7, r0 <== NOT EXECUTED
if ((percent & 1) == 0)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
last_percent = percent;
}
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
1f180: e2855001 add r5, r5, #1 <== NOT EXECUTED
sector_cnt--;
1f184: e2466064 sub r6, r6, #100 ; 0x64 <== NOT EXECUTED 1f188: e1a0b004 mov fp, r4 <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
"Filling : ");
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
1f18c: 0a00000c beq 1f1c4 <msdos_format_fill_sectors+0xe8> <== NOT EXECUTED
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
1f190: e1a0100a mov r1, sl <== NOT EXECUTED 1f194: e1a00006 mov r0, r6 <== NOT EXECUTED 1f198: eb00ef52 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
if (percent != last_percent) {
1f19c: e150000b cmp r0, fp <== NOT EXECUTED
/*
* write to consecutive sectors
*/
while ((ret_val == 0) &&
(sector_cnt > 0)) {
int percent = (sector_cnt * 100) / total_sectors;
1f1a0: e1a04000 mov r4, r0 <== NOT EXECUTED
if (percent != last_percent) {
1f1a4: 0affffe8 beq 1f14c <msdos_format_fill_sectors+0x70> <== NOT EXECUTED
if ((percent & 1) == 0)
1f1a8: e3100001 tst r0, #1 <== NOT EXECUTED 1f1ac: 1affffe6 bne 1f14c <msdos_format_fill_sectors+0x70> <== NOT EXECUTED
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, ".");
1f1b0: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 1f1b4: e3a01002 mov r1, #2 <== NOT EXECUTED 1f1b8: e59f2098 ldr r2, [pc, #152] ; 1f258 <msdos_format_fill_sectors+0x17c><== NOT EXECUTED 1f1bc: ebffff9b bl 1f030 <msdos_format_printf> <== NOT EXECUTED 1f1c0: eaffffe1 b 1f14c <msdos_format_fill_sectors+0x70> <== NOT EXECUTED
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
1f1c4: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 1f1c8: e3a01002 mov r1, #2 <== NOT EXECUTED 1f1cc: e59f2088 ldr r2, [pc, #136] ; 1f25c <msdos_format_fill_sectors+0x180><== NOT EXECUTED 1f1d0: ebffff96 bl 1f030 <msdos_format_printf> <== NOT EXECUTED
if (ret_val)
1f1d4: e3570000 cmp r7, #0 <== NOT EXECUTED 1f1d8: 1a000010 bne 1f220 <msdos_format_fill_sectors+0x144> <== NOT EXECUTED
/*
* cleanup
*/
if (fill_buffer != NULL) {
free(fill_buffer);
1f1dc: e1a00009 mov r0, r9 <== NOT EXECUTED 1f1e0: ebffa2e2 bl 7d70 <free> <== NOT EXECUTED
fill_buffer = NULL;
}
return ret_val;
}
1f1e4: e1a00007 mov r0, r7 <== NOT EXECUTED
1f1e8: e28dd008 add sp, sp, #8 <== NOT EXECUTED
1f1ec: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* allocate and fill buffer
*/
if (ret_val == 0) {
fill_buffer = malloc(sector_size);
if (fill_buffer == NULL) {
errno = ENOMEM;
1f1f0: eb008f7e bl 42ff0 <__errno> <== NOT EXECUTED 1f1f4: e3a0300c mov r3, #12 <== NOT EXECUTED 1f1f8: e5803000 str r3, [r0] <== NOT EXECUTED
else {
memset(fill_buffer,fill_byte,sector_size);
}
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL,
1f1fc: e3a01002 mov r1, #2 <== NOT EXECUTED 1f200: e59f204c ldr r2, [pc, #76] ; 1f254 <msdos_format_fill_sectors+0x178><== NOT EXECUTED 1f204: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 1f208: ebffff88 bl 1f030 <msdos_format_printf> <== NOT EXECUTED
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
1f20c: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 1f210: e3a01002 mov r1, #2 <== NOT EXECUTED 1f214: e59f2040 ldr r2, [pc, #64] ; 1f25c <msdos_format_fill_sectors+0x180><== NOT EXECUTED 1f218: ebffff84 bl 1f030 <msdos_format_printf> <== NOT EXECUTED 1f21c: e3e07000 mvn r7, #0 <== NOT EXECUTED
if (ret_val)
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_INFO,
1f220: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 1f224: e1a03005 mov r3, r5 <== NOT EXECUTED 1f228: e3a01001 mov r1, #1 <== NOT EXECUTED 1f22c: e59f202c ldr r2, [pc, #44] ; 1f260 <msdos_format_fill_sectors+0x184><== NOT EXECUTED 1f230: ebffff7e bl 1f030 <msdos_format_printf> <== NOT EXECUTED
"filling error on sector: %d\n", start_sector);
/*
* cleanup
*/
if (fill_buffer != NULL) {
1f234: e3590000 cmp r9, #0 <== NOT EXECUTED 1f238: 0affffe9 beq 1f1e4 <msdos_format_fill_sectors+0x108> <== NOT EXECUTED 1f23c: eaffffe6 b 1f1dc <msdos_format_fill_sectors+0x100> <== NOT EXECUTED
ret_val = msdos_format_write_sec(fd,start_sector,sector_size,fill_buffer);
start_sector++;
sector_cnt--;
}
msdos_format_printf (rqdata, MSDOS_FMT_INFO_LEVEL_DETAIL, "\n");
1f240: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 1f244: e3a01002 mov r1, #2 <== NOT EXECUTED 1f248: e59f200c ldr r2, [pc, #12] ; 1f25c <msdos_format_fill_sectors+0x180><== NOT EXECUTED 1f24c: ebffff77 bl 1f030 <msdos_format_printf> <== NOT EXECUTED 1f250: eaffffe1 b 1f1dc <msdos_format_fill_sectors+0x100> <== NOT EXECUTED
0001f030 <msdos_format_printf>:
*/
static void
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
1f030: e92d000c push {r2, r3} <== NOT EXECUTED
1f034: e92d4010 push {r4, lr} <== NOT EXECUTED
1f038: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
va_list args; va_start (args, format);
1f03c: e28d2010 add r2, sp, #16 <== NOT EXECUTED
if (rqdata != NULL && rqdata->info_level >= info_level)
1f040: e3500000 cmp r0, #0 <== NOT EXECUTED
msdos_format_printf (const msdos_format_request_param_t *rqdata,
int info_level,
const char *format, ...)
{
va_list args;
va_start (args, format);
1f044: e58d2000 str r2, [sp] <== NOT EXECUTED
if (rqdata != NULL && rqdata->info_level >= info_level)
1f048: 0a00000a beq 1f078 <msdos_format_printf+0x48> <== NOT EXECUTED 1f04c: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 1f050: e1530001 cmp r3, r1 <== NOT EXECUTED 1f054: ba000007 blt 1f078 <msdos_format_printf+0x48> <== NOT EXECUTED
{
vfprintf (stdout, format, args);
1f058: e59f4028 ldr r4, [pc, #40] ; 1f088 <msdos_format_printf+0x58><== NOT EXECUTED 1f05c: e5943000 ldr r3, [r4] <== NOT EXECUTED 1f060: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 1f064: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 1f068: eb00cafd bl 51c64 <vfprintf> <== NOT EXECUTED
fflush (stdout);
1f06c: e5943000 ldr r3, [r4] <== NOT EXECUTED 1f070: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED 1f074: eb0090d0 bl 433bc <fflush> <== NOT EXECUTED
} va_end (args); }
1f078: e28dd004 add sp, sp, #4 <== NOT EXECUTED
1f07c: e8bd4010 pop {r4, lr} <== NOT EXECUTED
1f080: e28dd008 add sp, sp, #8 <== NOT EXECUTED
1f084: e12fff1e bx lr <== NOT EXECUTED
0001f08c <msdos_format_write_sec>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
1f08c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
1f090: e0876192 umull r6, r7, r2, r1 <== NOT EXECUTED
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
1f094: e1a04002 mov r4, r2 <== NOT EXECUTED
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
1f098: e1a01006 mov r1, r6 <== NOT EXECUTED
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
1f09c: e1a05003 mov r5, r3 <== NOT EXECUTED
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
1f0a0: e1a02007 mov r2, r7 <== NOT EXECUTED 1f0a4: e3a03000 mov r3, #0 <== NOT EXECUTED
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
1f0a8: e1a06000 mov r6, r0 <== NOT EXECUTED
int ret_val = 0;
if (0 > lseek(fd,((off_t)start_sector)*sector_size,SEEK_SET)) {
1f0ac: eb002b44 bl 29dc4 <lseek> <== NOT EXECUTED 1f0b0: e3510000 cmp r1, #0 <== NOT EXECUTED 1f0b4: ba000006 blt 1f0d4 <msdos_format_write_sec+0x48> <== NOT EXECUTED
ret_val = -1;
}
if (ret_val == 0) {
if (0 > write(fd,buffer,sector_size)) {
1f0b8: e1a00006 mov r0, r6 <== NOT EXECUTED
1f0bc: e1a01005 mov r1, r5 <== NOT EXECUTED
1f0c0: e1a02004 mov r2, r4 <== NOT EXECUTED
1f0c4: ebffb285 bl bae0 <write> <== NOT EXECUTED
1f0c8: e3500000 cmp r0, #0 <== NOT EXECUTED
1f0cc: a3a00000 movge r0, #0 <== NOT EXECUTED
1f0d0: a8bd80f0 popge {r4, r5, r6, r7, pc} <== NOT EXECUTED
1f0d4: e3e00000 mvn r0, #0 <== NOT EXECUTED
ret_val = -1;
}
}
return ret_val;
}
1f0d8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00036dc0 <msdos_free_node_info>:
int
msdos_free_node_info(rtems_filesystem_location_info_t *pathloc)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
36dc0: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
* RC_OK on success, or -1 code if error occured
*
*/
int
msdos_free_node_info(rtems_filesystem_location_info_t *pathloc)
{
36dc4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
36dc8: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36dcc: e3a01000 mov r1, #0 <== NOT EXECUTED
* RC_OK on success, or -1 code if error occured
*
*/
int
msdos_free_node_info(rtems_filesystem_location_info_t *pathloc)
{
36dd0: e1a04000 mov r4, r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
36dd4: e1a02001 mov r2, r1 <== NOT EXECUTED 36dd8: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED 36ddc: ebff55b8 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
36de0: e3500000 cmp r0, #0 <== NOT EXECUTED 36de4: 1a000007 bne 36e08 <msdos_free_node_info+0x48> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
rc = fat_file_close(pathloc->mt_entry, pathloc->node_access);
36de8: e5941000 ldr r1, [r4] <== NOT EXECUTED 36dec: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 36df0: ebffbb58 bl 25b58 <fat_file_close> <== NOT EXECUTED 36df4: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
36df8: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED 36dfc: ebff55f8 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
36e00: e1a00004 mov r0, r4 <== NOT EXECUTED
36e04: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
36e08: eb003078 bl 42ff0 <__errno> <== NOT EXECUTED 36e0c: e3a03005 mov r3, #5 <== NOT EXECUTED 36e10: e5803000 str r3, [r0] <== NOT EXECUTED 36e14: e3e04000 mvn r4, #0 <== NOT EXECUTED 36e18: eafffff8 b 36e00 <msdos_free_node_info+0x40> <== NOT EXECUTED
00038190 <msdos_get_dotdot_dir_info_cluster_num_and_offset>:
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
38190: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
38194: e24dd058 sub sp, sp, #88 ; 0x58 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
fat_file_fd_t *fat_fd = NULL;
38198: e28d5058 add r5, sp, #88 ; 0x58 <== NOT EXECUTED 3819c: e3a0c000 mov ip, #0 <== NOT EXECUTED 381a0: e525c004 str ip, [r5, #-4]! <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
381a4: e1a07002 mov r7, r2 <== NOT EXECUTED 381a8: e1a08001 mov r8, r1 <== NOT EXECUTED
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
381ac: e1a01002 mov r1, r2 <== NOT EXECUTED 381b0: e1a02005 mov r2, r5 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln,
fat_dir_pos_t *dir_pos,
char *dir_entry
)
{
381b4: e1a06000 mov r6, r0 <== NOT EXECUTED 381b8: e1a09003 mov r9, r3 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
381bc: e590b034 ldr fp, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t cl4find = 0;
/*
* open fat-file corresponded to ".."
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
381c0: ebffb68e bl 25c00 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
381c4: e2504000 subs r4, r0, #0 <== NOT EXECUTED 381c8: 0a000002 beq 381d8 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x48><== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
rc = fat_file_close(mt_entry, fat_fd);
return rc;
}
381cc: e1a00004 mov r0, r4 <== NOT EXECUTED
381d0: e28dd058 add sp, sp, #88 ; 0x58 <== NOT EXECUTED
381d4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
381d8: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
381dc: e3a03602 mov r3, #2097152 ; 0x200000 <== NOT EXECUTED
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
fat_fd->fat_file_type = FAT_DIRECTORY;
381e0: e3a0a001 mov sl, #1 <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
381e4: e5814034 str r4, [r1, #52] ; 0x34 <== NOT EXECUTED
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
381e8: e5813014 str r3, [r1, #20] <== NOT EXECUTED
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
381ec: e5818038 str r8, [r1, #56] ; 0x38 <== NOT EXECUTED
*/
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
fat_fd->cln = cln;
381f0: e581801c str r8, [r1, #28] <== NOT EXECUTED
fat_fd->fat_file_type = FAT_DIRECTORY;
381f4: e581a010 str sl, [r1, #16] <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
rc = fat_file_size(mt_entry, fat_fd);
381f8: e1a00006 mov r0, r6 <== NOT EXECUTED 381fc: ebffb38a bl 2502c <fat_file_size> <== NOT EXECUTED
if (rc != RC_OK)
38200: e2504000 subs r4, r0, #0 <== NOT EXECUTED 38204: 1a00006d bne 383c0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x230><== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
38208: e28d8034 add r8, sp, #52 ; 0x34 <== NOT EXECUTED 3820c: e288c008 add ip, r8, #8 <== NOT EXECUTED 38210: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 38214: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 38218: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 3821c: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 38220: e48c4004 str r4, [ip], #4 <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
38224: e1a0100a mov r1, sl <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
38228: e58c4000 str r4, [ip] <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
3822c: e1a02008 mov r2, r8 <== NOT EXECUTED 38230: e3a0300b mov r3, #11 <== NOT EXECUTED 38234: e59f0194 ldr r0, [pc, #404] ; 383d0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x240><== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find "." node in opened directory */
memset(dot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
38238: e58d4034 str r4, [sp, #52] ; 0x34 <== NOT EXECUTED 3823c: e58d4038 str r4, [sp, #56] ; 0x38 <== NOT EXECUTED
msdos_long_to_short(".", 1, dot_node, MSDOS_SHORT_NAME_LEN);
38240: ebffff5b bl 37fb4 <msdos_long_to_short> <== NOT EXECUTED
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, ".", 1,
38244: e1a02004 mov r2, r4 <== NOT EXECUTED 38248: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED 3824c: e1a00006 mov r0, r6 <== NOT EXECUTED 38250: e59f3178 ldr r3, [pc, #376] ; 383d0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x240><== NOT EXECUTED 38254: e58da000 str sl, [sp] <== NOT EXECUTED 38258: e58da004 str sl, [sp, #4] <== NOT EXECUTED 3825c: e58d7008 str r7, [sp, #8] <== NOT EXECUTED 38260: e58d800c str r8, [sp, #12] <== NOT EXECUTED 38264: ebfffb59 bl 36fd0 <msdos_find_name_in_fat_file> <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos, dot_node);
if (rc != RC_OK)
38268: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3826c: 1a000053 bne 383c0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x230><== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
38270: e28d3014 add r3, sp, #20 <== NOT EXECUTED 38274: e283c008 add ip, r3, #8 <== NOT EXECUTED 38278: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 3827c: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 38280: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 38284: e48c4004 str r4, [ip], #4 <== NOT EXECUTED 38288: e48c4004 str r4, [ip], #4 <== NOT EXECUTED
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
3828c: e1a02003 mov r2, r3 <== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
38290: e58c4000 str r4, [ip] <== NOT EXECUTED
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
38294: e3a01002 mov r1, #2 <== NOT EXECUTED 38298: e3a0300b mov r3, #11 <== NOT EXECUTED 3829c: e59f0130 ldr r0, [pc, #304] ; 383d4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x244><== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* find ".." node in opened directory */
memset(dotdot_node, 0, MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE);
382a0: e58d4014 str r4, [sp, #20] <== NOT EXECUTED 382a4: e58d4018 str r4, [sp, #24] <== NOT EXECUTED
msdos_long_to_short("..", 2, dotdot_node, MSDOS_SHORT_NAME_LEN);
382a8: ebffff41 bl 37fb4 <msdos_long_to_short> <== NOT EXECUTED
rc = msdos_find_name_in_fat_file(mt_entry, fat_fd, false, "..", 2,
382ac: e3a0c002 mov ip, #2 <== NOT EXECUTED 382b0: e1a02004 mov r2, r4 <== NOT EXECUTED 382b4: e58dc000 str ip, [sp] <== NOT EXECUTED 382b8: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED 382bc: e28dc014 add ip, sp, #20 <== NOT EXECUTED 382c0: e1a00006 mov r0, r6 <== NOT EXECUTED 382c4: e59f3108 ldr r3, [pc, #264] ; 383d4 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x244><== NOT EXECUTED 382c8: e58da004 str sl, [sp, #4] <== NOT EXECUTED 382cc: e58d7008 str r7, [sp, #8] <== NOT EXECUTED 382d0: e58dc00c str ip, [sp, #12] <== NOT EXECUTED 382d4: ebfffb3d bl 36fd0 <msdos_find_name_in_fat_file> <== NOT EXECUTED
MSDOS_NAME_SHORT, dir_pos,
dotdot_node);
if (rc != RC_OK)
382d8: e2504000 subs r4, r0, #0 <== NOT EXECUTED 382dc: 1a000037 bne 383c0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x230><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
382e0: e1d831b4 ldrh r3, [r8, #20] <== NOT EXECUTED
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(mt_entry, fat_fd);
382e4: e1a00006 mov r0, r6 <== NOT EXECUTED 382e8: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
cl4find = MSDOS_EXTRACT_CLUSTER_NUM(dot_node);
382ec: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 382f0: e1d881ba ldrh r8, [r8, #26] <== NOT EXECUTED
/* close fat-file corresponded to ".." directory */
rc = fat_file_close(mt_entry, fat_fd);
382f4: ebffb617 bl 25b58 <fat_file_close> <== NOT EXECUTED
if ( rc != RC_OK )
382f8: e2504000 subs r4, r0, #0 <== NOT EXECUTED 382fc: 1affffb2 bne 381cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x3c><== NOT EXECUTED
return rc;
if ( (MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
38300: e1dd22b8 ldrh r2, [sp, #40] ; 0x28 <== NOT EXECUTED 38304: e1dd32be ldrh r3, [sp, #46] ; 0x2e <== NOT EXECUTED 38308: e1933802 orrs r3, r3, r2, lsl #16 <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
3830c: 03e01000 mvneq r1, #0 <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
38310: 0587100c streq r1, [r7, #12] <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
38314: 05871008 streq r1, [r7, #8] <== NOT EXECUTED
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
38318: 05873004 streq r3, [r7, #4] <== NOT EXECUTED
/*
* we handle root dir for all FAT types in the same way with the
* ordinary directories ( through fat_file_* calls )
*/
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
3831c: 0587a000 streq sl, [r7] <== NOT EXECUTED
}
/* open fat-file corresponded to second ".." */
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
38320: e1a02005 mov r2, r5 <== NOT EXECUTED 38324: e1a00006 mov r0, r6 <== NOT EXECUTED 38328: e1a01007 mov r1, r7 <== NOT EXECUTED 3832c: ebffb633 bl 25c00 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
38330: e2504000 subs r4, r0, #0 <== NOT EXECUTED 38334: 1affffa4 bne 381cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x3c><== NOT EXECUTED
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
38338: e1dd22b8 ldrh r2, [sp, #40] ; 0x28 <== NOT EXECUTED 3833c: e1dd32be ldrh r3, [sp, #46] ; 0x2e <== NOT EXECUTED 38340: e1933802 orrs r3, r3, r2, lsl #16 <== NOT EXECUTED
fat_fd->cln = fs_info->fat.vol.rdir_cl;
38344: 059d1054 ldreq r1, [sp, #84] ; 0x54 <== NOT EXECUTED
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
38348: 159d1054 ldrne r1, [sp, #84] ; 0x54 <== NOT EXECUTED
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
3834c: 059b3038 ldreq r3, [fp, #56] ; 0x38 <== NOT EXECUTED
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
38350: 1581301c strne r3, [r1, #28] <== NOT EXECUTED
rc = fat_file_open(mt_entry, dir_pos, &fat_fd);
if (rc != RC_OK)
return rc;
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
38354: 0581301c streq r3, [r1, #28] <== NOT EXECUTED
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
38358: e3a02001 mov r2, #1 <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
3835c: e591301c ldr r3, [r1, #28] <== NOT EXECUTED
if ((MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node)) == 0)
fat_fd->cln = fs_info->fat.vol.rdir_cl;
else
fat_fd->cln = MSDOS_EXTRACT_CLUSTER_NUM(dotdot_node);
fat_fd->fat_file_type = FAT_DIRECTORY;
38360: e5812010 str r2, [r1, #16] <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
38364: e3a02602 mov r2, #2097152 ; 0x200000 <== NOT EXECUTED 38368: e5812014 str r2, [r1, #20] <== NOT EXECUTED
fat_fd->map.file_cln = 0;
3836c: e3a02000 mov r2, #0 <== NOT EXECUTED 38370: e5812034 str r2, [r1, #52] ; 0x34 <== NOT EXECUTED
fat_fd->map.disk_cln = fat_fd->cln;
38374: e5813038 str r3, [r1, #56] ; 0x38 <== NOT EXECUTED
rc = fat_file_size(mt_entry, fat_fd);
38378: e1a00006 mov r0, r6 <== NOT EXECUTED 3837c: ebffb32a bl 2502c <fat_file_size> <== NOT EXECUTED
if (rc != RC_OK)
38380: e2504000 subs r4, r0, #0 <== NOT EXECUTED 38384: 1a00000d bne 383c0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x230><== NOT EXECUTED
fat_file_close(mt_entry, fat_fd);
return rc;
}
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
38388: e59dc010 ldr ip, [sp, #16] <== NOT EXECUTED 3838c: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED 38390: e188280c orr r2, r8, ip, lsl #16 <== NOT EXECUTED 38394: e1a03007 mov r3, r7 <== NOT EXECUTED 38398: e1a00006 mov r0, r6 <== NOT EXECUTED 3839c: e58d9000 str r9, [sp] <== NOT EXECUTED 383a0: ebfffab0 bl 36e68 <msdos_find_node_by_cluster_num_in_fat_file><== NOT EXECUTED
dir_pos, dir_entry);
if (rc != RC_OK)
383a4: e2504000 subs r4, r0, #0 <== NOT EXECUTED 383a8: 1a000004 bne 383c0 <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x230><== NOT EXECUTED
{
fat_file_close(mt_entry, fat_fd);
return rc;
}
rc = fat_file_close(mt_entry, fat_fd);
383ac: e1a00006 mov r0, r6 <== NOT EXECUTED 383b0: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED 383b4: ebffb5e7 bl 25b58 <fat_file_close> <== NOT EXECUTED 383b8: e1a04000 mov r4, r0 <== NOT EXECUTED
return rc;
383bc: eaffff82 b 381cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x3c><== NOT EXECUTED
/* in this directory find slot with specified cluster num */
rc = msdos_find_node_by_cluster_num_in_fat_file(mt_entry, fat_fd, cl4find,
dir_pos, dir_entry);
if (rc != RC_OK)
{
fat_file_close(mt_entry, fat_fd);
383c0: e1a00006 mov r0, r6 <== NOT EXECUTED 383c4: e59d1054 ldr r1, [sp, #84] ; 0x54 <== NOT EXECUTED 383c8: ebffb5e2 bl 25b58 <fat_file_close> <== NOT EXECUTED
return rc;
383cc: eaffff7e b 381cc <msdos_get_dotdot_dir_info_cluster_num_and_offset+0x3c><== NOT EXECUTED
000383d8 <msdos_get_name_node>:
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
383d8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
383dc: e1a05001 mov r5, r1 <== NOT EXECUTED
383e0: e24dd010 sub sp, sp, #16 <== NOT EXECUTED
383e4: e1a04000 mov r4, r0 <== NOT EXECUTED
383e8: e1a08002 mov r8, r2 <== NOT EXECUTED
383ec: e28d6030 add r6, sp, #48 ; 0x30 <== NOT EXECUTED
383f0: e89600c0 ldm r6, {r6, r7} <== NOT EXECUTED
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
383f4: e59dc02c ldr ip, [sp, #44] ; 0x2c <== NOT EXECUTED
int name_len,
msdos_name_type_t name_type,
fat_dir_pos_t *dir_pos,
char *name_dir_entry
)
{
383f8: e20550ff and r5, r5, #255 ; 0xff <== NOT EXECUTED
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
383fc: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED 38400: e5941000 ldr r1, [r4] <== NOT EXECUTED 38404: e1a02005 mov r2, r5 <== NOT EXECUTED 38408: e58d3000 str r3, [sp] <== NOT EXECUTED 3840c: e1a03008 mov r3, r8 <== NOT EXECUTED 38410: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 38414: e58d6008 str r6, [sp, #8] <== NOT EXECUTED 38418: e58d700c str r7, [sp, #12] <== NOT EXECUTED 3841c: ebfffaeb bl 36fd0 <msdos_find_name_in_fat_file> <== NOT EXECUTED
create_node, name, name_len, name_type,
dir_pos, name_dir_entry);
if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))
38420: e3a03c7d mov r3, #32000 ; 0x7d00 <== NOT EXECUTED 38424: e2833001 add r3, r3, #1 <== NOT EXECUTED 38428: e1500003 cmp r0, r3 <== NOT EXECUTED 3842c: 13500000 cmpne r0, #0 <== NOT EXECUTED
int rc = RC_OK;
fat_file_fd_t *fat_fd = parent_loc->node_access;
uint32_t dotdot_cln = 0;
/* find name in fat-file which corresponds to the directory */
rc = msdos_find_name_in_fat_file(parent_loc->mt_entry, fat_fd,
38430: e1a0a000 mov sl, r0 <== NOT EXECUTED
create_node, name, name_len, name_type,
dir_pos, name_dir_entry);
if ((rc != RC_OK) && (rc != MSDOS_NAME_NOT_FOUND_ERR))
38434: 1a000015 bne 38490 <msdos_get_name_node+0xb8> <== NOT EXECUTED
return rc;
if (!create_node)
38438: e3550000 cmp r5, #0 <== NOT EXECUTED 3843c: 1a000013 bne 38490 <msdos_get_name_node+0xb8> <== NOT EXECUTED
{
/* if we search for valid name and name not found -> return */
if (rc == MSDOS_NAME_NOT_FOUND_ERR)
38440: e1500003 cmp r0, r3 <== NOT EXECUTED 38444: 0a000011 beq 38490 <msdos_get_name_node+0xb8> <== NOT EXECUTED
* if we have deal with ".." - it is a special case :(((
*
* Really, we should return cluster num and offset not of ".." slot, but
* slot which correspondes to real directory name.
*/
if (rc == RC_OK)
38448: e3500000 cmp r0, #0 <== NOT EXECUTED 3844c: 1a00000f bne 38490 <msdos_get_name_node+0xb8> <== NOT EXECUTED
{
if (strncmp(name, "..", 2) == 0)
38450: e1a00008 mov r0, r8 <== NOT EXECUTED 38454: e59f1058 ldr r1, [pc, #88] ; 384b4 <msdos_get_name_node+0xdc><== NOT EXECUTED 38458: e3a02002 mov r2, #2 <== NOT EXECUTED 3845c: eb00462a bl 49d0c <strncmp> <== NOT EXECUTED 38460: e3500000 cmp r0, #0 <== NOT EXECUTED 38464: 1a000009 bne 38490 <msdos_get_name_node+0xb8> <== NOT EXECUTED
{
dotdot_cln = MSDOS_EXTRACT_CLUSTER_NUM((name_dir_entry));
38468: e1d711b4 ldrh r1, [r7, #20] <== NOT EXECUTED 3846c: e1d731ba ldrh r3, [r7, #26] <== NOT EXECUTED
/* are we right under root dir ? */
if (dotdot_cln == 0)
38470: e1931801 orrs r1, r3, r1, lsl #16 <== NOT EXECUTED 38474: 1a000008 bne 3849c <msdos_get_name_node+0xc4> <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
38478: e3e03000 mvn r3, #0 <== NOT EXECUTED
/*
* we can relax about first_char field - it never should be
* used for root dir
*/
fat_dir_pos_init(dir_pos);
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
3847c: e3a02001 mov r2, #1 <== NOT EXECUTED 38480: e5862000 str r2, [r6] <== NOT EXECUTED
dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
38484: e586300c str r3, [r6, #12] <== NOT EXECUTED
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
38488: e586a004 str sl, [r6, #4] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
3848c: e5863008 str r3, [r6, #8] <== NOT EXECUTED
}
}
}
}
return rc;
}
38490: e1a0000a mov r0, sl <== NOT EXECUTED
38494: e28dd010 add sp, sp, #16 <== NOT EXECUTED
38498: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
}
else
{
rc =
msdos_get_dotdot_dir_info_cluster_num_and_offset(parent_loc->mt_entry,
3849c: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 384a0: e1a02006 mov r2, r6 <== NOT EXECUTED 384a4: e1a03007 mov r3, r7 <== NOT EXECUTED
}
}
}
}
return rc;
}
384a8: e28dd010 add sp, sp, #16 <== NOT EXECUTED
384ac: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
dir_pos->sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
}
else
{
rc =
msdos_get_dotdot_dir_info_cluster_num_and_offset(parent_loc->mt_entry,
384b0: eaffff36 b 38190 <msdos_get_dotdot_dir_info_cluster_num_and_offset><== NOT EXECUTED
00037ed8 <msdos_get_token>:
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
37ed8: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
msdos_token_types_t type = MSDOS_NAME;
int i = 0;
*ret_token = NULL;
37edc: e3a06000 mov r6, #0 <== NOT EXECUTED
*ret_token_len = 0;
if (pathlen == 0)
37ee0: e2518000 subs r8, r1, #0 <== NOT EXECUTED
msdos_token_types_t
msdos_get_token(const char *path,
int pathlen,
const char **ret_token,
int *ret_token_len)
{
37ee4: e1a07000 mov r7, r0 <== NOT EXECUTED 37ee8: e1a04002 mov r4, r2 <== NOT EXECUTED 37eec: e1a05003 mov r5, r3 <== NOT EXECUTED
msdos_token_types_t type = MSDOS_NAME;
int i = 0;
*ret_token = NULL;
37ef0: e5826000 str r6, [r2] <== NOT EXECUTED
*ret_token_len = 0;
37ef4: e5836000 str r6, [r3] <== NOT EXECUTED
if (pathlen == 0)
37ef8: 01a00008 moveq r0, r8 <== NOT EXECUTED
37efc: 1a000009 bne 37f28 <msdos_get_token+0x50> <== NOT EXECUTED
37f00: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
return MSDOS_NO_MORE_PATH;
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
37f04: e1560008 cmp r6, r8 <== NOT EXECUTED 37f08: aa00000a bge 37f38 <msdos_get_token+0x60> <== NOT EXECUTED
{
if ( !msdos_is_valid_name_char(path[i]) )
37f0c: e7d70006 ldrb r0, [r7, r6] <== NOT EXECUTED 37f10: ebffffd5 bl 37e6c <msdos_is_valid_name_char> <== NOT EXECUTED 37f14: e3500000 cmp r0, #0 <== NOT EXECUTED
return MSDOS_INVALID_TOKEN;
++i;
37f18: e2866001 add r6, r6, #1 <== NOT EXECUTED
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
{
if ( !msdos_is_valid_name_char(path[i]) )
37f1c: 0a00000f beq 37f60 <msdos_get_token+0x88> <== NOT EXECUTED
return MSDOS_INVALID_TOKEN;
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
37f20: e3560f41 cmp r6, #260 ; 0x104 <== NOT EXECUTED 37f24: 0a00000d beq 37f60 <msdos_get_token+0x88> <== NOT EXECUTED
return MSDOS_NO_MORE_PATH;
/*
* Check for a separator.
*/
while (!msdos_is_separator(path[i]) && (i < pathlen))
37f28: e7d70006 ldrb r0, [r7, r6] <== NOT EXECUTED 37f2c: ebff4619 bl 9798 <rtems_filesystem_is_separator> <== NOT EXECUTED 37f30: e3500000 cmp r0, #0 <== NOT EXECUTED 37f34: 0afffff2 beq 37f04 <msdos_get_token+0x2c> <== NOT EXECUTED
*ret_token = path;
/*
* If it is just a separator then it is the current dir.
*/
if ( i == 0 )
37f38: e2563000 subs r3, r6, #0 <== NOT EXECUTED
++i;
if ( i == MSDOS_NAME_MAX_LFN_WITH_DOT )
return MSDOS_INVALID_TOKEN;
}
*ret_token = path;
37f3c: e5847000 str r7, [r4] <== NOT EXECUTED
/*
* If it is just a separator then it is the current dir.
*/
if ( i == 0 )
37f40: 1a000008 bne 37f68 <msdos_get_token+0x90> <== NOT EXECUTED
{
if ( (*path != '\0') && pathlen )
37f44: e5d72000 ldrb r2, [r7] <== NOT EXECUTED 37f48: e3520000 cmp r2, #0 <== NOT EXECUTED 37f4c: 13a03001 movne r3, #1 <== NOT EXECUTED 37f50: 11a00003 movne r0, r3 <== NOT EXECUTED
{
type = MSDOS_UP_DIR;
return type;
}
if ((i == 1) && ((*ret_token)[0] == '.'))
37f54: 01a00003 moveq r0, r3 <== NOT EXECUTED
}
/*
* Set the token and token_len to the token start and length.
*/
*ret_token_len = i;
37f58: e5853000 str r3, [r5] <== NOT EXECUTED
37f5c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
{
type = MSDOS_UP_DIR;
return type;
}
if ((i == 1) && ((*ret_token)[0] == '.'))
37f60: e3a00004 mov r0, #4 <== NOT EXECUTED
return type;
}
}
return type;
}
37f64: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == MSDOS_NAME )
{
if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
37f68: e3560002 cmp r6, #2 <== NOT EXECUTED
}
/*
* Set the token and token_len to the token start and length.
*/
*ret_token_len = i;
37f6c: e5856000 str r6, [r5] <== NOT EXECUTED
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == MSDOS_NAME )
{
if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
37f70: 0a000008 beq 37f98 <msdos_get_token+0xc0> <== NOT EXECUTED
{
type = MSDOS_UP_DIR;
return type;
}
if ((i == 1) && ((*ret_token)[0] == '.'))
37f74: e3560001 cmp r6, #1 <== NOT EXECUTED
37f78: 0a000001 beq 37f84 <msdos_get_token+0xac> <== NOT EXECUTED
37f7c: e3a00003 mov r0, #3 <== NOT EXECUTED
37f80: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
37f84: e5d73000 ldrb r3, [r7] <== NOT EXECUTED
37f88: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED
37f8c: 1afffffa bne 37f7c <msdos_get_token+0xa4> <== NOT EXECUTED
37f90: e1a00006 mov r0, r6 <== NOT EXECUTED
37f94: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
* If we copied something that was not a seperator see if
* it was a special name.
*/
if ( type == MSDOS_NAME )
{
if ((i == 2) && ((*ret_token)[0] == '.') && ((*ret_token)[1] == '.'))
37f98: e5d73000 ldrb r3, [r7] <== NOT EXECUTED 37f9c: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED 37fa0: 1afffff5 bne 37f7c <msdos_get_token+0xa4> <== NOT EXECUTED 37fa4: e5d73001 ldrb r3, [r7, #1] <== NOT EXECUTED 37fa8: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED 37fac: 1afffff2 bne 37f7c <msdos_get_token+0xa4> <== NOT EXECUTED 37fb0: eafffff6 b 37f90 <msdos_get_token+0xb8> <== NOT EXECUTED
000200e0 <msdos_initialize_support>:
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *file_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers
)
{
200e0: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
200e4: e3a0c000 mov ip, #0 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *file_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers
)
{
200e8: e24dd018 sub sp, sp, #24 <== NOT EXECUTED 200ec: e1a05000 mov r5, r0 <== NOT EXECUTED 200f0: e1a09001 mov r9, r1 <== NOT EXECUTED
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
200f4: e3a00001 mov r0, #1 <== NOT EXECUTED 200f8: e3a0109c mov r1, #156 ; 0x9c <== NOT EXECUTED
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
200fc: e58dc014 str ip, [sp, #20] <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *temp_mt_entry,
const rtems_filesystem_operations_table *op_table,
const rtems_filesystem_file_handlers_r *file_handlers,
const rtems_filesystem_file_handlers_r *directory_handlers
)
{
20100: e1a0a002 mov sl, r2 <== NOT EXECUTED 20104: e1a06003 mov r6, r3 <== NOT EXECUTED
msdos_fs_info_t *fs_info = NULL;
fat_file_fd_t *fat_fd = NULL;
fat_dir_pos_t root_pos;
uint32_t cl_buf_size;
fs_info = (msdos_fs_info_t *)calloc(1, sizeof(msdos_fs_info_t));
20108: ebff9d94 bl 7760 <calloc> <== NOT EXECUTED
if (!fs_info)
2010c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 20110: 0a000050 beq 20258 <msdos_initialize_support+0x178> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
temp_mt_entry->fs_info = fs_info;
20114: e5854034 str r4, [r5, #52] ; 0x34 <== NOT EXECUTED
rc = fat_init_volume_info(temp_mt_entry);
20118: e1a00005 mov r0, r5 <== NOT EXECUTED 2011c: eb001970 bl 266e4 <fat_init_volume_info> <== NOT EXECUTED
if (rc != RC_OK)
20120: e2507000 subs r7, r0, #0 <== NOT EXECUTED 20124: 1a000032 bne 201f4 <msdos_initialize_support+0x114> <== NOT EXECUTED
/*
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
20128: e28d1018 add r1, sp, #24 <== NOT EXECUTED 2012c: e3a08001 mov r8, #1 <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
20130: e3e03000 mvn r3, #0 <== NOT EXECUTED 20134: e5218014 str r8, [r1, #-20]! <== NOT EXECUTED
{
free(fs_info);
return rc;
}
fs_info->file_handlers = file_handlers;
20138: e584a090 str sl, [r4, #144] ; 0x90 <== NOT EXECUTED
fs_info->directory_handlers = directory_handlers;
2013c: e584608c str r6, [r4, #140] ; 0x8c <== NOT EXECUTED
* open fat-file which correspondes to root directory
* (so inode number 0x00000010 is always used for root directory)
*/
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
20140: e1a00005 mov r0, r5 <== NOT EXECUTED 20144: e28d2014 add r2, sp, #20 <== NOT EXECUTED
fat_dir_pos_init(
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
20148: e58d7008 str r7, [sp, #8] <== NOT EXECUTED
dir_pos->lname.cln = FAT_FILE_SHORT_NAME; dir_pos->lname.ofs = FAT_FILE_SHORT_NAME;
2014c: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
fat_dir_pos_t *dir_pos
)
{
dir_pos->sname.cln = 0;
dir_pos->sname.ofs = 0;
dir_pos->lname.cln = FAT_FILE_SHORT_NAME;
20150: e58d300c str r3, [sp, #12] <== NOT EXECUTED 20154: eb0016a9 bl 25c00 <fat_file_open> <== NOT EXECUTED
if (rc != RC_OK)
20158: e2507000 subs r7, r0, #0 <== NOT EXECUTED 2015c: 1a000022 bne 201ec <msdos_initialize_support+0x10c> <== NOT EXECUTED
free(fs_info);
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
20160: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
20164: e3a03602 mov r3, #2097152 ; 0x200000 <== NOT EXECUTED 20168: e5813014 str r3, [r1, #20] <== NOT EXECUTED
fat_fd->cln = fs_info->fat.vol.rdir_cl;
2016c: e5943038 ldr r3, [r4, #56] ; 0x38 <== NOT EXECUTED
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
20170: e3530000 cmp r3, #0 <== NOT EXECUTED
free(fs_info);
return rc;
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
20174: e5818010 str r8, [r1, #16] <== NOT EXECUTED
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
fat_fd->map.file_cln = 0;
20178: e5817034 str r7, [r1, #52] ; 0x34 <== NOT EXECUTED
}
/* again: unfortunately "fat-file" is just almost fat file :( */
fat_fd->fat_file_type = FAT_DIRECTORY;
fat_fd->size_limit = MSDOS_MAX_DIR_LENGHT;
fat_fd->cln = fs_info->fat.vol.rdir_cl;
2017c: e581301c str r3, [r1, #28] <== NOT EXECUTED
fat_fd->map.file_cln = 0;
fat_fd->map.disk_cln = fat_fd->cln;
20180: e5813038 str r3, [r1, #56] ; 0x38 <== NOT EXECUTED
/* if we have FAT12/16 */
if ( fat_fd->cln == 0 )
20184: 1a00001f bne 20208 <msdos_initialize_support+0x128> <== NOT EXECUTED
{
fat_fd->fat_file_size = fs_info->fat.vol.rdir_size;
20188: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 2018c: e5813018 str r3, [r1, #24] <== NOT EXECUTED
cl_buf_size = (fs_info->fat.vol.bpc > fs_info->fat.vol.rdir_size) ?
20190: e1d400b6 ldrh r0, [r4, #6] <== NOT EXECUTED 20194: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED 20198: e1500003 cmp r0, r3 <== NOT EXECUTED 2019c: 31a00003 movcc r0, r3 <== NOT EXECUTED
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
201a0: e3a01001 mov r1, #1 <== NOT EXECUTED 201a4: ebff9d6d bl 7760 <calloc> <== NOT EXECUTED
if (fs_info->cl_buf == NULL)
201a8: e3500000 cmp r0, #0 <== NOT EXECUTED
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
201ac: e5840098 str r0, [r4, #152] ; 0x98 <== NOT EXECUTED
if (fs_info->cl_buf == NULL)
201b0: 0a000021 beq 2023c <msdos_initialize_support+0x15c> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
free(fs_info);
rtems_set_errno_and_return_minus_one(ENOMEM);
}
sc = rtems_semaphore_create(3,
201b4: e284c094 add ip, r4, #148 ; 0x94 <== NOT EXECUTED 201b8: e3a00003 mov r0, #3 <== NOT EXECUTED 201bc: e3a01001 mov r1, #1 <== NOT EXECUTED 201c0: e3a02010 mov r2, #16 <== NOT EXECUTED 201c4: e3a03000 mov r3, #0 <== NOT EXECUTED 201c8: e58dc000 str ip, [sp] <== NOT EXECUTED 201cc: ebffb007 bl c1f0 <rtems_semaphore_create> <== NOT EXECUTED
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
201d0: e2507000 subs r7, r0, #0 <== NOT EXECUTED 201d4: 1a000024 bne 2026c <msdos_initialize_support+0x18c> <== NOT EXECUTED
free(fs_info->cl_buf);
free(fs_info);
rtems_set_errno_and_return_minus_one( EIO );
}
temp_mt_entry->mt_fs_root.node_access = fat_fd;
201d8: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
temp_mt_entry->mt_fs_root.ops = op_table;
201dc: e5859028 str r9, [r5, #40] ; 0x28 <== NOT EXECUTED
free(fs_info->cl_buf);
free(fs_info);
rtems_set_errno_and_return_minus_one( EIO );
}
temp_mt_entry->mt_fs_root.node_access = fat_fd;
201e0: e585301c str r3, [r5, #28] <== NOT EXECUTED
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
201e4: e5856024 str r6, [r5, #36] ; 0x24 <== NOT EXECUTED
temp_mt_entry->mt_fs_root.ops = op_table;
return rc;
201e8: ea000003 b 201fc <msdos_initialize_support+0x11c> <== NOT EXECUTED
fat_dir_pos_init(&root_pos);
root_pos.sname.cln = FAT_ROOTDIR_CLUSTER_NUM;
rc = fat_file_open(temp_mt_entry, &root_pos, &fat_fd);
if (rc != RC_OK)
{
fat_shutdown_drive(temp_mt_entry);
201ec: e1a00005 mov r0, r5 <== NOT EXECUTED 201f0: eb001898 bl 26458 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
201f4: e1a00004 mov r0, r4 <== NOT EXECUTED 201f8: ebff9edc bl 7d70 <free> <== NOT EXECUTED
temp_mt_entry->mt_fs_root.node_access = fat_fd;
temp_mt_entry->mt_fs_root.handlers = directory_handlers;
temp_mt_entry->mt_fs_root.ops = op_table;
return rc;
}
201fc: e1a00007 mov r0, r7 <== NOT EXECUTED
20200: e28dd018 add sp, sp, #24 <== NOT EXECUTED
20204: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
fs_info->fat.vol.bpc :
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(temp_mt_entry, fat_fd);
20208: e1a00005 mov r0, r5 <== NOT EXECUTED 2020c: eb001386 bl 2502c <fat_file_size> <== NOT EXECUTED
if ( rc != RC_OK )
20210: e2507000 subs r7, r0, #0 <== NOT EXECUTED
fat_file_close(temp_mt_entry, fat_fd);
fat_shutdown_drive(temp_mt_entry);
free(fs_info);
return rc;
}
cl_buf_size = fs_info->fat.vol.bpc;
20214: 01d400b6 ldrheq r0, [r4, #6] <== NOT EXECUTED
fs_info->fat.vol.rdir_size;
}
else
{
rc = fat_file_size(temp_mt_entry, fat_fd);
if ( rc != RC_OK )
20218: 0affffe0 beq 201a0 <msdos_initialize_support+0xc0> <== NOT EXECUTED
{
fat_file_close(temp_mt_entry, fat_fd);
2021c: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 20220: e1a00005 mov r0, r5 <== NOT EXECUTED 20224: eb00164b bl 25b58 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
20228: e1a00005 mov r0, r5 <== NOT EXECUTED 2022c: eb001889 bl 26458 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
20230: e1a00004 mov r0, r4 <== NOT EXECUTED 20234: ebff9ecd bl 7d70 <free> <== NOT EXECUTED
return rc;
20238: eaffffef b 201fc <msdos_initialize_support+0x11c> <== NOT EXECUTED
}
fs_info->cl_buf = (uint8_t *)calloc(cl_buf_size, sizeof(char));
if (fs_info->cl_buf == NULL)
{
fat_file_close(temp_mt_entry, fat_fd);
2023c: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 20240: e1a00005 mov r0, r5 <== NOT EXECUTED 20244: eb001643 bl 25b58 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
20248: e1a00005 mov r0, r5 <== NOT EXECUTED 2024c: eb001881 bl 26458 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info);
20250: e1a00004 mov r0, r4 <== NOT EXECUTED 20254: ebff9ec5 bl 7d70 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENOMEM);
20258: eb008b64 bl 42ff0 <__errno> <== NOT EXECUTED 2025c: e3a0300c mov r3, #12 <== NOT EXECUTED 20260: e5803000 str r3, [r0] <== NOT EXECUTED 20264: e3e07000 mvn r7, #0 <== NOT EXECUTED 20268: eaffffe3 b 201fc <msdos_initialize_support+0x11c> <== NOT EXECUTED
RTEMS_BINARY_SEMAPHORE | RTEMS_FIFO,
0,
&fs_info->vol_sema);
if (sc != RTEMS_SUCCESSFUL)
{
fat_file_close(temp_mt_entry, fat_fd);
2026c: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 20270: e1a00005 mov r0, r5 <== NOT EXECUTED 20274: eb001637 bl 25b58 <fat_file_close> <== NOT EXECUTED
fat_shutdown_drive(temp_mt_entry);
20278: e1a00005 mov r0, r5 <== NOT EXECUTED 2027c: eb001875 bl 26458 <fat_shutdown_drive> <== NOT EXECUTED
free(fs_info->cl_buf);
20280: e5940098 ldr r0, [r4, #152] ; 0x98 <== NOT EXECUTED 20284: ebff9eb9 bl 7d70 <free> <== NOT EXECUTED
free(fs_info);
20288: e1a00004 mov r0, r4 <== NOT EXECUTED 2028c: ebff9eb7 bl 7d70 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EIO );
20290: eb008b56 bl 42ff0 <__errno> <== NOT EXECUTED 20294: e3a03005 mov r3, #5 <== NOT EXECUTED 20298: e5803000 str r3, [r0] <== NOT EXECUTED 2029c: e3e07000 mvn r7, #0 <== NOT EXECUTED 202a0: eaffffd5 b 201fc <msdos_initialize_support+0x11c> <== NOT EXECUTED
00037e6c <msdos_is_valid_name_char>:
* MSDOS_NAME_LONG - Valid in a long name only.
*
*/
static msdos_name_type_t
msdos_is_valid_name_char(const char ch)
{
37e6c: e92d4010 push {r4, lr} <== NOT EXECUTED
37e70: e20040ff and r4, r0, #255 ; 0xff <== NOT EXECUTED
if (strchr(" +,;=[]", ch) != NULL)
37e74: e1a01004 mov r1, r4 <== NOT EXECUTED
37e78: e59f004c ldr r0, [pc, #76] ; 37ecc <msdos_is_valid_name_char+0x60><== NOT EXECUTED
37e7c: eb004489 bl 490a8 <strchr> <== NOT EXECUTED
37e80: e3500000 cmp r0, #0 <== NOT EXECUTED
37e84: 13a00002 movne r0, #2 <== NOT EXECUTED
37e88: 18bd8010 popne {r4, pc} <== NOT EXECUTED
return MSDOS_NAME_LONG;
if ((ch == '.') || isalnum((unsigned char)ch) ||
37e8c: e354002e cmp r4, #46 ; 0x2e <== NOT EXECUTED 37e90: 0a00000b beq 37ec4 <msdos_is_valid_name_char+0x58> <== NOT EXECUTED 37e94: e59f3034 ldr r3, [pc, #52] ; 37ed0 <msdos_is_valid_name_char+0x64><== NOT EXECUTED 37e98: e5933000 ldr r3, [r3] <== NOT EXECUTED 37e9c: e0833004 add r3, r3, r4 <== NOT EXECUTED 37ea0: e5d33001 ldrb r3, [r3, #1] <== NOT EXECUTED 37ea4: e3130007 tst r3, #7 <== NOT EXECUTED 37ea8: 1a000005 bne 37ec4 <msdos_is_valid_name_char+0x58> <== NOT EXECUTED
(strchr("$%'-_@~`!(){}^#&", ch) != NULL))
37eac: e1a01004 mov r1, r4 <== NOT EXECUTED
37eb0: e59f001c ldr r0, [pc, #28] ; 37ed4 <msdos_is_valid_name_char+0x68><== NOT EXECUTED
37eb4: eb00447b bl 490a8 <strchr> <== NOT EXECUTED
37eb8: e2500000 subs r0, r0, #0 <== NOT EXECUTED
37ebc: 13a00001 movne r0, #1 <== NOT EXECUTED
37ec0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
37ec4: e3a00001 mov r0, #1 <== NOT EXECUTED
return MSDOS_NAME_SHORT;
return MSDOS_NAME_INVALID;
}
37ec8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00037fb4 <msdos_long_to_short>:
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
37fb4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
37fb8: e1a06002 mov r6, r2 <== NOT EXECUTED
37fbc: e1a05000 mov r5, r0 <== NOT EXECUTED
37fc0: e1a04001 mov r4, r1 <== NOT EXECUTED
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
37fc4: e1a02003 mov r2, r3 <== NOT EXECUTED
*
*/
#define MSDOS_L2S_PRINT 0
msdos_name_type_t
msdos_long_to_short(const char *lfn, int lfn_len, char* sfn, int sfn_len)
{
37fc8: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
int i;
/*
* Fill with spaces. This is how a short directory entry is padded.
*/
memset (sfn, ' ', sfn_len);
37fcc: e1a00006 mov r0, r6 <== NOT EXECUTED 37fd0: e3a01020 mov r1, #32 <== NOT EXECUTED 37fd4: eb00393c bl 464cc <memset> <== NOT EXECUTED
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
37fd8: e5d58000 ldrb r8, [r5] <== NOT EXECUTED 37fdc: e358002e cmp r8, #46 ; 0x2e <== NOT EXECUTED 37fe0: 13a03000 movne r3, #0 <== NOT EXECUTED 37fe4: 03a03001 moveq r3, #1 <== NOT EXECUTED 37fe8: e3540001 cmp r4, #1 <== NOT EXECUTED 37fec: 0358002e cmpeq r8, #46 ; 0x2e <== NOT EXECUTED
{
sfn[0] = '.';
37ff0: 03a0302e moveq r3, #46 ; 0x2e <== NOT EXECUTED 37ff4: 05c63000 strbeq r3, [r6] <== NOT EXECUTED 37ff8: 03a07001 moveq r7, #1 <== NOT EXECUTED
memset (sfn, ' ', sfn_len);
/*
* Handle '.' and '..' specially.
*/
if ((lfn[0] == '.') && (lfn_len == 1))
37ffc: 0a000043 beq 38110 <msdos_long_to_short+0x15c> <== NOT EXECUTED
printf ("MSDOS_L2S: SHORT[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
38000: e3530000 cmp r3, #0 <== NOT EXECUTED 38004: 1a000053 bne 38158 <msdos_long_to_short+0x1a4> <== NOT EXECUTED
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
38008: e3540000 cmp r4, #0 <== NOT EXECUTED 3800c: d3a03000 movle r3, #0 <== NOT EXECUTED 38010: da000048 ble 38138 <msdos_long_to_short+0x184> <== NOT EXECUTED
if ((lfn[i] != ' ') && (lfn[i] != '.'))
38014: e3580020 cmp r8, #32 <== NOT EXECUTED 38018: 1358002e cmpne r8, #46 ; 0x2e <== NOT EXECUTED 3801c: 03a03000 moveq r3, #0 <== NOT EXECUTED 38020: 13a03001 movne r3, #1 <== NOT EXECUTED 38024: 0a000040 beq 3812c <msdos_long_to_short+0x178> <== NOT EXECUTED
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
38028: e3580000 cmp r8, #0 <== NOT EXECUTED 3802c: 13540000 cmpne r4, #0 <== NOT EXECUTED 38030: da000054 ble 38188 <msdos_long_to_short+0x1d4> <== NOT EXECUTED 38034: e3a03000 mov r3, #0 <== NOT EXECUTED 38038: e58d3000 str r3, [sp] <== NOT EXECUTED 3803c: e1a0b003 mov fp, r3 <== NOT EXECUTED 38040: e1a0a003 mov sl, r3 <== NOT EXECUTED 38044: e3e09000 mvn r9, #0 <== NOT EXECUTED 38048: ea000011 b 38094 <msdos_long_to_short+0xe0> <== NOT EXECUTED
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
{
if (is_dot || ((count - dot_at) > 3))
3804c: e3530000 cmp r3, #0 <== NOT EXECUTED 38050: 1a000029 bne 380fc <msdos_long_to_short+0x148> <== NOT EXECUTED 38054: e069300a rsb r3, r9, sl <== NOT EXECUTED 38058: e3530003 cmp r3, #3 <== NOT EXECUTED 3805c: ca000026 bgt 380fc <msdos_long_to_short+0x148> <== NOT EXECUTED
}
}
if (is_dot)
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
38060: e2483041 sub r3, r8, #65 ; 0x41 <== NOT EXECUTED 38064: e3530019 cmp r3, #25 <== NOT EXECUTED 38068: 93a03001 movls r3, #1 <== NOT EXECUTED 3806c: 958d3000 strls r3, [sp] <== NOT EXECUTED 38070: 9a000002 bls 38080 <msdos_long_to_short+0xcc> <== NOT EXECUTED
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
38074: e2488061 sub r8, r8, #97 ; 0x61 <== NOT EXECUTED 38078: e3580019 cmp r8, #25 <== NOT EXECUTED 3807c: 93a0b001 movls fp, #1 <== NOT EXECUTED
lowercase = true;
count++;
38080: e28aa001 add sl, sl, #1 <== NOT EXECUTED
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
38084: e7d5800a ldrb r8, [r5, sl] <== NOT EXECUTED 38088: e3580000 cmp r8, #0 <== NOT EXECUTED 3808c: 1154000a cmpne r4, sl <== NOT EXECUTED 38090: da000014 ble 380e8 <msdos_long_to_short+0x134> <== NOT EXECUTED
{
bool is_dot = *name == '.';
msdos_name_type_t type = msdos_is_valid_name_char(*name);
38094: e1a00008 mov r0, r8 <== NOT EXECUTED 38098: ebffff73 bl 37e6c <msdos_is_valid_name_char> <== NOT EXECUTED
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
3809c: e3500000 cmp r0, #0 <== NOT EXECUTED 380a0: 13500002 cmpne r0, #2 <== NOT EXECUTED
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
msdos_name_type_t type = msdos_is_valid_name_char(*name);
380a4: e1a07000 mov r7, r0 <== NOT EXECUTED
#if MSDOS_NAME_TYPE_PRINT
printf ("MSDOS_NAME_TYPE: c:%02x type:%d\n", *name, type);
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
380a8: 0a000033 beq 3817c <msdos_long_to_short+0x1c8> <== NOT EXECUTED
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
{
bool is_dot = *name == '.';
380ac: e358002e cmp r8, #46 ; 0x2e <== NOT EXECUTED 380b0: 13a03000 movne r3, #0 <== NOT EXECUTED 380b4: 03a03001 moveq r3, #1 <== NOT EXECUTED
#endif
if ((type == MSDOS_NAME_INVALID) || (type == MSDOS_NAME_LONG))
return type;
if (dot_at >= 0)
380b8: e3790001 cmn r9, #1 <== NOT EXECUTED 380bc: 1affffe2 bne 3804c <msdos_long_to_short+0x98> <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
380c0: e35a0008 cmp sl, #8 <== NOT EXECUTED 380c4: 0a00001f beq 38148 <msdos_long_to_short+0x194> <== NOT EXECUTED
#endif
return MSDOS_NAME_LONG;
}
}
if (is_dot)
380c8: e3530000 cmp r3, #0 <== NOT EXECUTED 380cc: 0affffe3 beq 38060 <msdos_long_to_short+0xac> <== NOT EXECUTED
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
380d0: e1a0900a mov r9, sl <== NOT EXECUTED
lowercase = true;
count++;
380d4: e28aa001 add sl, sl, #1 <== NOT EXECUTED
bool lowercase = false;
bool uppercase = false;
int dot_at = -1;
int count = 0;
while (*name && (count < name_len))
380d8: e7d5800a ldrb r8, [r5, sl] <== NOT EXECUTED 380dc: e3580000 cmp r8, #0 <== NOT EXECUTED 380e0: 1154000a cmpne r4, sl <== NOT EXECUTED 380e4: caffffea bgt 38094 <msdos_long_to_short+0xe0> <== NOT EXECUTED
count++;
name++;
}
if (lowercase && uppercase)
380e8: e35b0000 cmp fp, #0 <== NOT EXECUTED 380ec: 0a000025 beq 38188 <msdos_long_to_short+0x1d4> <== NOT EXECUTED 380f0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 380f4: e3530000 cmp r3, #0 <== NOT EXECUTED 380f8: 0a000022 beq 38188 <msdos_long_to_short+0x1d4> <== NOT EXECUTED
msdos_filename_unix2dos (lfn, lfn_len, sfn);
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
380fc: e3a07002 mov r7, #2 <== NOT EXECUTED
printf ("MSDOS_L2S: INVALID[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_INVALID;
}
msdos_filename_unix2dos (lfn, lfn_len, sfn);
38100: e1a00005 mov r0, r5 <== NOT EXECUTED 38104: e1a01004 mov r1, r4 <== NOT EXECUTED 38108: e1a02006 mov r2, r6 <== NOT EXECUTED 3810c: eb002586 bl 4172c <msdos_filename_unix2dos> <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
}
38110: e1a00007 mov r0, r7 <== NOT EXECUTED
38114: e28dd004 add sp, sp, #4 <== NOT EXECUTED
38118: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
if ((lfn[i] != ' ') && (lfn[i] != '.'))
3811c: e7d52003 ldrb r2, [r5, r3] <== NOT EXECUTED 38120: e352002e cmp r2, #46 ; 0x2e <== NOT EXECUTED 38124: 13520020 cmpne r2, #32 <== NOT EXECUTED 38128: 1affffbe bne 38028 <msdos_long_to_short+0x74> <== NOT EXECUTED
}
/*
* Filenames with only blanks and dots are not allowed!
*/
for (i = 0; i < lfn_len; i++)
3812c: e2833001 add r3, r3, #1 <== NOT EXECUTED 38130: e1540003 cmp r4, r3 <== NOT EXECUTED 38134: cafffff8 bgt 3811c <msdos_long_to_short+0x168> <== NOT EXECUTED
if ((lfn[i] != ' ') && (lfn[i] != '.'))
break;
if (i == lfn_len)
38138: e1530004 cmp r3, r4 <== NOT EXECUTED 3813c: 03a07000 moveq r7, #0 <== NOT EXECUTED 38140: 1affffb8 bne 38028 <msdos_long_to_short+0x74> <== NOT EXECUTED 38144: eafffff1 b 38110 <msdos_long_to_short+0x15c> <== NOT EXECUTED
return MSDOS_NAME_LONG;
}
}
else
{
if (count == 8 && !is_dot)
38148: e3530000 cmp r3, #0 <== NOT EXECUTED 3814c: 0affffea beq 380fc <msdos_long_to_short+0x148> <== NOT EXECUTED
if (is_dot)
dot_at = count;
else if ((*name >= 'A') && (*name <= 'Z'))
uppercase = true;
else if ((*name >= 'a') && (*name <= 'z'))
38150: e1a0900a mov r9, sl <== NOT EXECUTED 38154: eaffffde b 380d4 <msdos_long_to_short+0x120> <== NOT EXECUTED
printf ("MSDOS_L2S: SHORT[1]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
}
if ((lfn[0] == '.') && (lfn[1] == '.') && (lfn_len == 2))
38158: e5d53001 ldrb r3, [r5, #1] <== NOT EXECUTED 3815c: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED 38160: 03540002 cmpeq r4, #2 <== NOT EXECUTED 38164: 1affffa7 bne 38008 <msdos_long_to_short+0x54> <== NOT EXECUTED
{
sfn[0] = sfn[1] = '.';
38168: e3a0302e mov r3, #46 ; 0x2e <== NOT EXECUTED 3816c: e5c63000 strb r3, [r6] <== NOT EXECUTED 38170: e5c63001 strb r3, [r6, #1] <== NOT EXECUTED 38174: e3a07001 mov r7, #1 <== NOT EXECUTED
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: SHORT[2]: lfn:'%s' SFN:'%s'\n", lfn, sfn);
#endif
return MSDOS_NAME_SHORT;
38178: eaffffe4 b 38110 <msdos_long_to_short+0x15c> <== NOT EXECUTED
* Is this a short name ?
*/
type = msdos_name_type (lfn, lfn_len);
if (type == MSDOS_NAME_INVALID)
3817c: e3500000 cmp r0, #0 <== NOT EXECUTED 38180: 0affffe2 beq 38110 <msdos_long_to_short+0x15c> <== NOT EXECUTED 38184: eaffffdd b 38100 <msdos_long_to_short+0x14c> <== NOT EXECUTED
msdos_filename_unix2dos (lfn, lfn_len, sfn);
#if MSDOS_L2S_PRINT
printf ("MSDOS_L2S: TYPE:%d lfn:'%s' SFN:'%s'\n", type, lfn, sfn);
#endif
return type;
38188: e3a07001 mov r7, #1 <== NOT EXECUTED 3818c: eaffffdb b 38100 <msdos_long_to_short+0x14c> <== NOT EXECUTED
000202a4 <msdos_mknod>:
const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
202a4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
202a8: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
202ac: e59d7024 ldr r7, [sp, #36] ; 0x24 <== NOT EXECUTED
msdos_token_types_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
202b0: e2013a0f and r3, r1, #61440 ; 0xf000 <== NOT EXECUTED
rtems_filesystem_location_info_t *pathloc
)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
202b4: e5972010 ldr r2, [r7, #16] <== NOT EXECUTED
msdos_token_types_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
202b8: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc
)
{
202bc: e1a04001 mov r4, r1 <== NOT EXECUTED 202c0: e1a08000 mov r8, r0 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = pathloc->mt_entry->fs_info;
202c4: e5925034 ldr r5, [r2, #52] ; 0x34 <== NOT EXECUTED
msdos_token_types_t type = 0;
/*
* Figure out what type of msdos node this is.
*/
if (S_ISDIR(mode))
202c8: 0a000016 beq 20328 <msdos_mknod+0x84> <== NOT EXECUTED
{
type = MSDOS_DIRECTORY;
}
else if (S_ISREG(mode))
202cc: e3530902 cmp r3, #32768 ; 0x8000 <== NOT EXECUTED 202d0: 03a0a005 moveq sl, #5 <== NOT EXECUTED 202d4: 1a00001a bne 20344 <msdos_mknod+0xa0> <== NOT EXECUTED
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
202d8: e3a01000 mov r1, #0 <== NOT EXECUTED 202dc: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED 202e0: e1a02001 mov r2, r1 <== NOT EXECUTED 202e4: ebffb076 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
202e8: e2506000 subs r6, r0, #0 <== NOT EXECUTED 202ec: 1a00000f bne 20330 <msdos_mknod+0x8c> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(EIO);
/* Create an MSDOS node */
rc = msdos_creat_node(pathloc, type, name, strlen(name), mode, NULL);
202f0: e1a00008 mov r0, r8 <== NOT EXECUTED
202f4: eb00a63a bl 49be4 <strlen> <== NOT EXECUTED
202f8: e1a0100a mov r1, sl <== NOT EXECUTED
202fc: e1a03000 mov r3, r0 <== NOT EXECUTED
20300: e1a02008 mov r2, r8 <== NOT EXECUTED
20304: e1a00007 mov r0, r7 <== NOT EXECUTED
20308: e88d0050 stm sp, {r4, r6} <== NOT EXECUTED
2030c: eb0056ee bl 35ecc <msdos_creat_node> <== NOT EXECUTED
20310: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_semaphore_release(fs_info->vol_sema);
20314: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED 20318: ebffb0b1 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
2031c: e1a00004 mov r0, r4 <== NOT EXECUTED
20320: e28dd008 add sp, sp, #8 <== NOT EXECUTED
20324: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
else if (S_ISREG(mode))
{
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
20328: e3a0a001 mov sl, #1 <== NOT EXECUTED 2032c: eaffffe9 b 202d8 <msdos_mknod+0x34> <== NOT EXECUTED
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
20330: eb008b2e bl 42ff0 <__errno> <== NOT EXECUTED 20334: e3a03005 mov r3, #5 <== NOT EXECUTED 20338: e5803000 str r3, [r0] <== NOT EXECUTED 2033c: e3e04000 mvn r4, #0 <== NOT EXECUTED 20340: eafffff5 b 2031c <msdos_mknod+0x78> <== NOT EXECUTED
else if (S_ISREG(mode))
{
type = MSDOS_REGULAR_FILE;
}
else
rtems_set_errno_and_return_minus_one(EINVAL);
20344: eb008b29 bl 42ff0 <__errno> <== NOT EXECUTED 20348: e3a03016 mov r3, #22 <== NOT EXECUTED 2034c: e5803000 str r3, [r0] <== NOT EXECUTED 20350: e3e04000 mvn r4, #0 <== NOT EXECUTED 20354: eafffff0 b 2031c <msdos_mknod+0x78> <== NOT EXECUTED
00020358 <msdos_node_type>:
* node type
*
*/
rtems_filesystem_node_types_t
msdos_node_type(rtems_filesystem_location_info_t *pathloc)
{
20358: e5903000 ldr r3, [r0] <== NOT EXECUTED
* call
*/
fat_fd = pathloc->node_access;
return fat_fd->fat_file_type;
}
2035c: e5930010 ldr r0, [r3, #16] <== NOT EXECUTED 20360: e12fff1e bx lr <== NOT EXECUTED
00020364 <msdos_rename>:
int
msdos_rename(rtems_filesystem_location_info_t *old_parent_loc,
rtems_filesystem_location_info_t *old_loc,
rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name)
{
20364: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
20368: e1a04003 mov r4, r3 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = new_parent_loc->mt_entry->fs_info;
2036c: e5923010 ldr r3, [r2, #16] <== NOT EXECUTED
int
msdos_rename(rtems_filesystem_location_info_t *old_parent_loc,
rtems_filesystem_location_info_t *old_loc,
rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name)
{
20370: e24dd010 sub sp, sp, #16 <== NOT EXECUTED
int len;
/*
* check spelling and format new node name
*/
if (MSDOS_NAME != msdos_get_token(new_name, strlen(new_name), &token, &len)) {
20374: e1a00004 mov r0, r4 <== NOT EXECUTED
int
msdos_rename(rtems_filesystem_location_info_t *old_parent_loc,
rtems_filesystem_location_info_t *old_loc,
rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name)
{
20378: e1a07001 mov r7, r1 <== NOT EXECUTED
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = new_parent_loc->mt_entry->fs_info;
2037c: e5936034 ldr r6, [r3, #52] ; 0x34 <== NOT EXECUTED
int
msdos_rename(rtems_filesystem_location_info_t *old_parent_loc,
rtems_filesystem_location_info_t *old_loc,
rtems_filesystem_location_info_t *new_parent_loc,
const char *new_name)
{
20380: e1a05002 mov r5, r2 <== NOT EXECUTED
int len;
/*
* check spelling and format new node name
*/
if (MSDOS_NAME != msdos_get_token(new_name, strlen(new_name), &token, &len)) {
20384: eb00a616 bl 49be4 <strlen> <== NOT EXECUTED 20388: e28d200c add r2, sp, #12 <== NOT EXECUTED 2038c: e1a01000 mov r1, r0 <== NOT EXECUTED 20390: e28d3008 add r3, sp, #8 <== NOT EXECUTED 20394: e1a00004 mov r0, r4 <== NOT EXECUTED
const char *new_name)
{
int rc = RC_OK;
rtems_status_code sc = RTEMS_SUCCESSFUL;
msdos_fs_info_t *fs_info = new_parent_loc->mt_entry->fs_info;
fat_file_fd_t *old_fat_fd = old_loc->node_access;
20398: e5978000 ldr r8, [r7] <== NOT EXECUTED
int len;
/*
* check spelling and format new node name
*/
if (MSDOS_NAME != msdos_get_token(new_name, strlen(new_name), &token, &len)) {
2039c: eb005ecd bl 37ed8 <msdos_get_token> <== NOT EXECUTED 203a0: e3500003 cmp r0, #3 <== NOT EXECUTED 203a4: e1a0a000 mov sl, r0 <== NOT EXECUTED 203a8: 1a000019 bne 20414 <msdos_rename+0xb0> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
}
/*
* lock volume
*/
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
203ac: e3a01000 mov r1, #0 <== NOT EXECUTED 203b0: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 203b4: e1a02001 mov r2, r1 <== NOT EXECUTED 203b8: ebffb041 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
203bc: e3500000 cmp r0, #0 <== NOT EXECUTED 203c0: 1a000018 bne 20428 <msdos_rename+0xc4> <== NOT EXECUTED
/*
* create new directory entry as "hard link", copying relevant info from
* existing file
*/
rc = msdos_creat_node(new_parent_loc,
203c4: e1a02004 mov r2, r4 <== NOT EXECUTED 203c8: e3a0c902 mov ip, #32768 ; 0x8000 <== NOT EXECUTED 203cc: e1a00005 mov r0, r5 <== NOT EXECUTED 203d0: e1a0100a mov r1, sl <== NOT EXECUTED 203d4: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 203d8: e58dc000 str ip, [sp] <== NOT EXECUTED 203dc: e58d8004 str r8, [sp, #4] <== NOT EXECUTED 203e0: eb0056b9 bl 35ecc <msdos_creat_node> <== NOT EXECUTED
MSDOS_HARD_LINK,new_name,len,S_IFREG,
old_fat_fd);
if (rc != RC_OK)
203e4: e2504000 subs r4, r0, #0 <== NOT EXECUTED 203e8: 1a000004 bne 20400 <msdos_rename+0x9c> <== NOT EXECUTED
}
/*
* mark file removed
*/
rc = msdos_set_first_char4file_name(old_loc->mt_entry,
203ec: e5970010 ldr r0, [r7, #16] <== NOT EXECUTED 203f0: e2881020 add r1, r8, #32 <== NOT EXECUTED 203f4: e3a020e5 mov r2, #229 ; 0xe5 <== NOT EXECUTED 203f8: eb005e10 bl 37c40 <msdos_set_first_char4file_name> <== NOT EXECUTED 203fc: e1a04000 mov r4, r0 <== NOT EXECUTED
&old_fat_fd->dir_pos,
MSDOS_THIS_DIR_ENTRY_EMPTY);
rtems_semaphore_release(fs_info->vol_sema);
20400: e5960094 ldr r0, [r6, #148] ; 0x94 <== NOT EXECUTED 20404: ebffb076 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return rc;
}
20408: e1a00004 mov r0, r4 <== NOT EXECUTED
2040c: e28dd010 add sp, sp, #16 <== NOT EXECUTED
20410: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
/*
* check spelling and format new node name
*/
if (MSDOS_NAME != msdos_get_token(new_name, strlen(new_name), &token, &len)) {
rtems_set_errno_and_return_minus_one(ENAMETOOLONG);
20414: eb008af5 bl 42ff0 <__errno> <== NOT EXECUTED 20418: e3a0305b mov r3, #91 ; 0x5b <== NOT EXECUTED 2041c: e5803000 str r3, [r0] <== NOT EXECUTED 20420: e3e04000 mvn r4, #0 <== NOT EXECUTED 20424: eafffff7 b 20408 <msdos_rename+0xa4> <== NOT EXECUTED
* lock volume
*/
sc = rtems_semaphore_obtain(fs_info->vol_sema, RTEMS_WAIT,
MSDOS_VOLUME_SEMAPHORE_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
rtems_set_errno_and_return_minus_one(EIO);
20428: eb008af0 bl 42ff0 <__errno> <== NOT EXECUTED 2042c: e3a03005 mov r3, #5 <== NOT EXECUTED 20430: e5803000 str r3, [r0] <== NOT EXECUTED 20434: e3e04000 mvn r4, #0 <== NOT EXECUTED 20438: eafffff2 b 20408 <msdos_rename+0xa4> <== NOT EXECUTED
00037db0 <msdos_set_dir_wrt_time_and_date>:
int
msdos_set_dir_wrt_time_and_date(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
37db0: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
37db4: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
37db8: e1a05001 mov r5, r1 <== NOT EXECUTED
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
37dbc: e28d8004 add r8, sp, #4 <== NOT EXECUTED 37dc0: e28d7006 add r7, sp, #6 <== NOT EXECUTED
int
msdos_set_dir_wrt_time_and_date(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
37dc4: e1a04000 mov r4, r0 <== NOT EXECUTED
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
37dc8: e1a02007 mov r2, r7 <== NOT EXECUTED 37dcc: e1a01008 mov r1, r8 <== NOT EXECUTED 37dd0: e5950040 ldr r0, [r5, #64] ; 0x40 <== NOT EXECUTED
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
37dd4: e594a034 ldr sl, [r4, #52] ; 0x34 <== NOT EXECUTED
uint16_t time_val;
uint16_t date;
uint32_t sec = 0;
uint32_t byte = 0;
msdos_date_unix2dos(fat_fd->mtime, &date, &time_val);
37dd8: eb0025a9 bl 41484 <msdos_date_unix2dos> <== NOT EXECUTED
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
37ddc: e5952020 ldr r2, [r5, #32] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
37de0: e3520000 cmp r2, #0 <== NOT EXECUTED
fat_cluster_num_to_sector_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
37de4: e5943034 ldr r3, [r4, #52] ; 0x34 <== NOT EXECUTED
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
37de8: 1a000003 bne 37dfc <msdos_set_dir_wrt_time_and_date+0x4c> <== NOT EXECUTED 37dec: e5d3100a ldrb r1, [r3, #10] <== NOT EXECUTED 37df0: e3110003 tst r1, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
37df4: 1593201c ldrne r2, [r3, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
37df8: 1a000003 bne 37e0c <msdos_set_dir_wrt_time_and_date+0x5c> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
37dfc: e5931030 ldr r1, [r3, #48] ; 0x30 <== NOT EXECUTED 37e00: e5d33005 ldrb r3, [r3, #5] <== NOT EXECUTED 37e04: e2422002 sub r2, r2, #2 <== NOT EXECUTED 37e08: e0812312 add r2, r1, r2, lsl r3 <== NOT EXECUTED
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
37e0c: e5953024 ldr r3, [r5, #36] ; 0x24 <== NOT EXECUTED 37e10: e5da6002 ldrb r6, [sl, #2] <== NOT EXECUTED 37e14: e0826633 add r6, r2, r3, lsr r6 <== NOT EXECUTED
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
37e18: e1da50b0 ldrh r5, [sl] <== NOT EXECUTED 37e1c: e2455001 sub r5, r5, #1 <== NOT EXECUTED 37e20: e0055003 and r5, r5, r3 <== NOT EXECUTED
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
37e24: e1a01006 mov r1, r6 <== NOT EXECUTED 37e28: e2852016 add r2, r5, #22 <== NOT EXECUTED 37e2c: e3a03002 mov r3, #2 <== NOT EXECUTED 37e30: e1a00004 mov r0, r4 <== NOT EXECUTED 37e34: e58d7000 str r7, [sp] <== NOT EXECUTED 37e38: ebffb935 bl 26314 <_fat_block_write> <== NOT EXECUTED
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
37e3c: e1a01006 mov r1, r6 <== NOT EXECUTED
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
time_val = CT_LE_W(time_val);
ret1 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WTIME_OFFSET,
37e40: e1a07000 mov r7, r0 <== NOT EXECUTED
2, (char *)(&time_val));
date = CT_LE_W(date);
ret2 = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_WDATE_OFFSET,
37e44: e2852018 add r2, r5, #24 <== NOT EXECUTED 37e48: e1a00004 mov r0, r4 <== NOT EXECUTED 37e4c: e3a03002 mov r3, #2 <== NOT EXECUTED 37e50: e58d8000 str r8, [sp] <== NOT EXECUTED 37e54: ebffb92e bl 26314 <_fat_block_write> <== NOT EXECUTED
2, (char *)(&date));
if ( (ret1 < 0) || (ret2 < 0) )
37e58: e1a07fa7 lsr r7, r7, #31 <== NOT EXECUTED 37e5c: e1970fa0 orrs r0, r7, r0, lsr #31 <== NOT EXECUTED
return -1;
return RC_OK;
}
37e60: 13e00000 mvnne r0, #0 <== NOT EXECUTED
37e64: e28dd008 add sp, sp, #8 <== NOT EXECUTED
37e68: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
00037b04 <msdos_set_file_size>:
int
msdos_set_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
37b04: e92d4010 push {r4, lr} <== NOT EXECUTED
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t le_new_length = 0;
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
37b08: e5913020 ldr r3, [r1, #32] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
37b0c: e3530000 cmp r3, #0 <== NOT EXECUTED
int
msdos_set_file_size(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
37b10: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
ssize_t ret = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
37b14: e590c034 ldr ip, [r0, #52] ; 0x34 <== NOT EXECUTED 37b18: 1a000003 bne 37b2c <msdos_set_file_size+0x28> <== NOT EXECUTED 37b1c: e5dc200a ldrb r2, [ip, #10] <== NOT EXECUTED 37b20: e3120003 tst r2, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
37b24: 159c301c ldrne r3, [ip, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
37b28: 1a000003 bne 37b3c <msdos_set_file_size+0x38> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
37b2c: e5dce005 ldrb lr, [ip, #5] <== NOT EXECUTED 37b30: e59c2030 ldr r2, [ip, #48] ; 0x30 <== NOT EXECUTED 37b34: e2433002 sub r3, r3, #2 <== NOT EXECUTED 37b38: e0823e13 add r3, r2, r3, lsl lr <== NOT EXECUTED
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
37b3c: e1dc20b0 ldrh r2, [ip] <== NOT EXECUTED
uint32_t le_new_length = 0;
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
37b40: e591e024 ldr lr, [r1, #36] ; 0x24 <== NOT EXECUTED
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
le_new_length = CT_LE_L((fat_fd->fat_file_size));
37b44: e5914018 ldr r4, [r1, #24] <== NOT EXECUTED
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
37b48: e2422001 sub r2, r2, #1 <== NOT EXECUTED
uint32_t le_new_length = 0;
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
37b4c: e5dc1002 ldrb r1, [ip, #2] <== NOT EXECUTED
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
le_new_length = CT_LE_L((fat_fd->fat_file_size));
37b50: e28dc008 add ip, sp, #8 <== NOT EXECUTED 37b54: e52c4004 str r4, [ip, #-4]! <== NOT EXECUTED
uint32_t sec = 0;
uint32_t byte = 0;
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
byte = (fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1));
37b58: e002200e and r2, r2, lr <== NOT EXECUTED
le_new_length = CT_LE_L((fat_fd->fat_file_size));
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_SIZE_OFFSET, 4,
37b5c: e083113e add r1, r3, lr, lsr r1 <== NOT EXECUTED 37b60: e282201c add r2, r2, #28 <== NOT EXECUTED 37b64: e3a03004 mov r3, #4 <== NOT EXECUTED 37b68: e58dc000 str ip, [sp] <== NOT EXECUTED 37b6c: ebffb9e8 bl 26314 <_fat_block_write> <== NOT EXECUTED
(char *)(&le_new_length));
if ( ret < 0 )
37b70: e3500000 cmp r0, #0 <== NOT EXECUTED
return -1;
return RC_OK;
}
37b74: b3e00000 mvnlt r0, #0 <== NOT EXECUTED
37b78: a3a00000 movge r0, #0 <== NOT EXECUTED
37b7c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
37b80: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00037c40 <msdos_set_first_char4file_name>:
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
37c40: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
37c44: e2814008 add r4, r1, #8 <== NOT EXECUTED
37c48: e8940018 ldm r4, {r3, r4} <== NOT EXECUTED
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
37c4c: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 37c50: e5cd2004 strb r2, [sp, #4] <== NOT EXECUTED
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
37c54: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 37c58: e58d400c str r4, [sp, #12] <== NOT EXECUTED
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
37c5c: e5903034 ldr r3, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
37c60: e5916000 ldr r6, [r1] <== NOT EXECUTED
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
37c64: e5932038 ldr r2, [r3, #56] ; 0x38 <== NOT EXECUTED 37c68: e1520006 cmp r2, r6 <== NOT EXECUTED
msdos_set_first_char4file_name(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_dir_pos_t *dir_pos,
unsigned char fchar
)
{
37c6c: e1a04000 mov r4, r0 <== NOT EXECUTED
ssize_t ret;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
37c70: e1a05003 mov r5, r3 <== NOT EXECUTED
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
37c74: e591a004 ldr sl, [r1, #4] <== NOT EXECUTED
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
37c78: 0a000041 beq 37d84 <msdos_set_first_char4file_name+0x144> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
37c7c: e5912008 ldr r2, [r1, #8] <== NOT EXECUTED 37c80: e3720001 cmn r2, #1 <== NOT EXECUTED
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
37c84: e1d380b6 ldrh r8, [r3, #6] <== NOT EXECUTED
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
37c88: 0a000044 beq 37da0 <msdos_set_first_char4file_name+0x160> <== NOT EXECUTED
start = dir_pos->sname;
37c8c: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED 37c90: e5d3c002 ldrb ip, [r3, #2] <== NOT EXECUTED 37c94: e1d320b0 ldrh r2, [r3] <== NOT EXECUTED 37c98: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 37c9c: e28d7004 add r7, sp, #4 <== NOT EXECUTED
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);
37ca0: e28d9008 add r9, sp, #8 <== NOT EXECUTED 37ca4: ea000006 b 37cc4 <msdos_set_first_char4file_name+0x84> <== NOT EXECUTED
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
37ca8: e2800020 add r0, r0, #32 <== NOT EXECUTED
if (start.ofs >= dir_block_size)
37cac: e1580000 cmp r8, r0 <== NOT EXECUTED
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
break;
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
37cb0: e58d000c str r0, [sp, #12] <== NOT EXECUTED
if (start.ofs >= dir_block_size)
37cb4: 9a00001f bls 37d38 <msdos_set_first_char4file_name+0xf8> <== NOT EXECUTED 37cb8: e5943034 ldr r3, [r4, #52] ; 0x34 <== NOT EXECUTED 37cbc: e5d5c002 ldrb ip, [r5, #2] <== NOT EXECUTED 37cc0: e1d520b0 ldrh r2, [r5] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
37cc4: e3510000 cmp r1, #0 <== NOT EXECUTED 37cc8: 1a000003 bne 37cdc <msdos_set_first_char4file_name+0x9c> <== NOT EXECUTED 37ccc: e5d3e00a ldrb lr, [r3, #10] <== NOT EXECUTED 37cd0: e31e0003 tst lr, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
37cd4: 1593101c ldrne r1, [r3, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
37cd8: 1a000003 bne 37cec <msdos_set_first_char4file_name+0xac> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
37cdc: e593e030 ldr lr, [r3, #48] ; 0x30 <== NOT EXECUTED 37ce0: e5d33005 ldrb r3, [r3, #5] <== NOT EXECUTED 37ce4: e2411002 sub r1, r1, #2 <== NOT EXECUTED 37ce8: e08e1311 add r1, lr, r1, lsl r3 <== NOT EXECUTED
{
uint32_t sec = (fat_cluster_num_to_sector_num(mt_entry, start.cln) +
(start.ofs >> fs_info->fat.vol.sec_log2));
uint32_t byte = (start.ofs & (fs_info->fat.vol.bps - 1));;
ret = _fat_block_write(mt_entry, sec, byte + MSDOS_FILE_NAME_OFFSET, 1,
37cec: e2422001 sub r2, r2, #1 <== NOT EXECUTED 37cf0: e0811c30 add r1, r1, r0, lsr ip <== NOT EXECUTED 37cf4: e0022000 and r2, r2, r0 <== NOT EXECUTED 37cf8: e3a03001 mov r3, #1 <== NOT EXECUTED 37cfc: e1a00004 mov r0, r4 <== NOT EXECUTED 37d00: e58d7000 str r7, [sp] <== NOT EXECUTED 37d04: ebffb982 bl 26314 <_fat_block_write> <== NOT EXECUTED
&fchar);
if (ret < 0)
37d08: e3500000 cmp r0, #0 <== NOT EXECUTED 37d0c: ba00001a blt 37d7c <msdos_set_first_char4file_name+0x13c> <== NOT EXECUTED
return -1;
if ((start.cln == end.cln) && (start.ofs == end.ofs))
37d10: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 37d14: e1510006 cmp r1, r6 <== NOT EXECUTED 37d18: 159d000c ldrne r0, [sp, #12] <== NOT EXECUTED 37d1c: 1affffe1 bne 37ca8 <msdos_set_first_char4file_name+0x68> <== NOT EXECUTED 37d20: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED 37d24: e150000a cmp r0, sl <== NOT EXECUTED 37d28: 1affffde bne 37ca8 <msdos_set_first_char4file_name+0x68> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
break;
rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);
if ( rc != RC_OK )
return rc;
start.ofs = 0;
37d2c: e3a00000 mov r0, #0 <== NOT EXECUTED
}
}
return RC_OK;
}
37d30: e28dd010 add sp, sp, #16 <== NOT EXECUTED
37d34: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
start.ofs += MSDOS_DIRECTORY_ENTRY_STRUCT_SIZE;
if (start.ofs >= dir_block_size)
{
int rc;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
37d38: e5953038 ldr r3, [r5, #56] ; 0x38 <== NOT EXECUTED 37d3c: e1530006 cmp r3, r6 <== NOT EXECUTED 37d40: 1a000002 bne 37d50 <msdos_set_first_char4file_name+0x110> <== NOT EXECUTED
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
37d44: e5d5300a ldrb r3, [r5, #10] <== NOT EXECUTED 37d48: e3130003 tst r3, #3 <== NOT EXECUTED 37d4c: 1afffff6 bne 37d2c <msdos_set_first_char4file_name+0xec> <== NOT EXECUTED
break;
rc = fat_get_fat_cluster(mt_entry, start.cln, &start.cln);
37d50: e1a00004 mov r0, r4 <== NOT EXECUTED 37d54: e1a02009 mov r2, r9 <== NOT EXECUTED 37d58: eb001c32 bl 3ee28 <fat_get_fat_cluster> <== NOT EXECUTED
if ( rc != RC_OK )
37d5c: e3500000 cmp r0, #0 <== NOT EXECUTED 37d60: 1afffff2 bne 37d30 <msdos_set_first_char4file_name+0xf0> <== NOT EXECUTED
return rc;
start.ofs = 0;
37d64: e58d000c str r0, [sp, #12] <== NOT EXECUTED 37d68: e5943034 ldr r3, [r4, #52] ; 0x34 <== NOT EXECUTED 37d6c: e5d5c002 ldrb ip, [r5, #2] <== NOT EXECUTED 37d70: e1d520b0 ldrh r2, [r5] <== NOT EXECUTED 37d74: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 37d78: eaffffd1 b 37cc4 <msdos_set_first_char4file_name+0x84> <== NOT EXECUTED 37d7c: e3e00000 mvn r0, #0 <== NOT EXECUTED 37d80: eaffffea b 37d30 <msdos_set_first_char4file_name+0xf0> <== NOT EXECUTED
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
37d84: e5d3200a ldrb r2, [r3, #10] <== NOT EXECUTED 37d88: e3120003 tst r2, #3 <== NOT EXECUTED
dir_block_size = fs_info->fat.vol.rdir_size;
37d8c: 15938028 ldrne r8, [r3, #40] ; 0x28 <== NOT EXECUTED
uint32_t dir_block_size;
fat_pos_t start = dir_pos->lname;
fat_pos_t end = dir_pos->sname;
if ((end.cln == fs_info->fat.vol.rdir_cl) &&
(fs_info->fat.vol.type & (FAT_FAT12 | FAT_FAT16)))
37d90: 0affffb9 beq 37c7c <msdos_set_first_char4file_name+0x3c> <== NOT EXECUTED
dir_block_size = fs_info->fat.vol.rdir_size;
else
dir_block_size = fs_info->fat.vol.bpc;
if (dir_pos->lname.cln == FAT_FILE_SHORT_NAME)
37d94: e5912008 ldr r2, [r1, #8] <== NOT EXECUTED 37d98: e3720001 cmn r2, #1 <== NOT EXECUTED 37d9c: 1affffba bne 37c8c <msdos_set_first_char4file_name+0x4c> <== NOT EXECUTED
start = dir_pos->sname;
37da0: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
37da4: e58d1008 str r1, [sp, #8] <== NOT EXECUTED
37da8: e58d200c str r2, [sp, #12] <== NOT EXECUTED
37dac: eaffffb6 b 37c8c <msdos_set_first_char4file_name+0x4c> <== NOT EXECUTED
00037b84 <msdos_set_first_cluster_num>:
int
msdos_set_first_cluster_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
37b84: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
37b88: e5913020 ldr r3, [r1, #32] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
37b8c: e3530000 cmp r3, #0 <== NOT EXECUTED
int
msdos_set_first_cluster_num(
rtems_filesystem_mount_table_entry_t *mt_entry,
fat_file_fd_t *fat_fd
)
{
37b90: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 37b94: e1a04000 mov r4, r0 <== NOT EXECUTED
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
37b98: e5902034 ldr r2, [r0, #52] ; 0x34 <== NOT EXECUTED
uint32_t new_cln = fat_fd->cln;
37b9c: e591701c ldr r7, [r1, #28] <== NOT EXECUTED 37ba0: 1a000003 bne 37bb4 <msdos_set_first_cluster_num+0x30> <== NOT EXECUTED 37ba4: e5d2000a ldrb r0, [r2, #10] <== NOT EXECUTED 37ba8: e3100003 tst r0, #3 <== NOT EXECUTED
return fs_info->vol.rdir_loc;
37bac: 1592301c ldrne r3, [r2, #28] <== NOT EXECUTED
uint32_t cln
)
{
register fat_fs_info_t *fs_info = mt_entry->fs_info;
if ( (cln == 0) && (fs_info->vol.type & (FAT_FAT12 | FAT_FAT16)) )
37bb0: 1a000003 bne 37bc4 <msdos_set_first_cluster_num+0x40> <== NOT EXECUTED
return fs_info->vol.rdir_loc;
return (((cln - FAT_RSRVD_CLN) << fs_info->vol.spc_log2) +
37bb4: e5d2c005 ldrb ip, [r2, #5] <== NOT EXECUTED 37bb8: e5920030 ldr r0, [r2, #48] ; 0x30 <== NOT EXECUTED 37bbc: e2433002 sub r3, r3, #2 <== NOT EXECUTED 37bc0: e0803c13 add r3, r0, r3, lsl ip <== NOT EXECUTED
/*
* calculate input for _fat_block_write: convert (cluster num, offset) to
* (sector num, new offset)
*/
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
37bc4: e5d26002 ldrb r6, [r2, #2] <== NOT EXECUTED 37bc8: e5911024 ldr r1, [r1, #36] ; 0x24 <== NOT EXECUTED 37bcc: e0836631 add r6, r3, r1, lsr r6 <== NOT EXECUTED
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
37bd0: e1d250b0 ldrh r5, [r2] <== NOT EXECUTED 37bd4: e2455001 sub r5, r5, #1 <== NOT EXECUTED 37bd8: e0055001 and r5, r5, r1 <== NOT EXECUTED
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
37bdc: e28dc006 add ip, sp, #6 <== NOT EXECUTED 37be0: e1a01006 mov r1, r6 <== NOT EXECUTED 37be4: e285201a add r2, r5, #26 <== NOT EXECUTED 37be8: e58dc000 str ip, [sp] <== NOT EXECUTED 37bec: e3a03002 mov r3, #2 <== NOT EXECUTED
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
uint16_t le_cl_low = 0;
uint16_t le_cl_hi = 0;
37bf0: e3a0c000 mov ip, #0 <== NOT EXECUTED
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
37bf4: e1a00004 mov r0, r4 <== NOT EXECUTED
sec = fat_cluster_num_to_sector_num(mt_entry, fat_fd->dir_pos.sname.cln);
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
37bf8: e1cd70b6 strh r7, [sp, #6] <== NOT EXECUTED
{
ssize_t ret1 = 0, ret2 = 0;
msdos_fs_info_t *fs_info = mt_entry->fs_info;
uint32_t new_cln = fat_fd->cln;
uint16_t le_cl_low = 0;
uint16_t le_cl_hi = 0;
37bfc: e1cdc0b4 strh ip, [sp, #4] <== NOT EXECUTED
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
37c00: ebffb9c3 bl 26314 <_fat_block_write> <== NOT EXECUTED
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
37c04: e1a07827 lsr r7, r7, #16 <== NOT EXECUTED 37c08: e28dc008 add ip, sp, #8 <== NOT EXECUTED 37c0c: e16c70b4 strh r7, [ip, #-4]! <== NOT EXECUTED
sec += (fat_fd->dir_pos.sname.ofs >> fs_info->fat.vol.sec_log2);
/* byte from points to start of 32bytes structure */
byte = fat_fd->dir_pos.sname.ofs & (fs_info->fat.vol.bps - 1);
le_cl_low = CT_LE_W((uint16_t )(new_cln & 0x0000FFFF));
ret1 = _fat_block_write(mt_entry, sec,
37c10: e1a08000 mov r8, r0 <== NOT EXECUTED
byte + MSDOS_FIRST_CLUSTER_LOW_OFFSET, 2,
(char *)(&le_cl_low));
le_cl_hi = CT_LE_W((uint16_t )((new_cln & 0xFFFF0000) >> 16));
ret2 = _fat_block_write(mt_entry, sec,
37c14: e1a01006 mov r1, r6 <== NOT EXECUTED 37c18: e1a00004 mov r0, r4 <== NOT EXECUTED 37c1c: e2852014 add r2, r5, #20 <== NOT EXECUTED 37c20: e3a03002 mov r3, #2 <== NOT EXECUTED 37c24: e58dc000 str ip, [sp] <== NOT EXECUTED 37c28: ebffb9b9 bl 26314 <_fat_block_write> <== NOT EXECUTED
byte + MSDOS_FIRST_CLUSTER_HI_OFFSET, 2,
(char *)(&le_cl_hi));
if ( (ret1 < 0) || (ret2 < 0) )
37c2c: e1a08fa8 lsr r8, r8, #31 <== NOT EXECUTED 37c30: e1980fa0 orrs r0, r8, r0, lsr #31 <== NOT EXECUTED
return -1;
return RC_OK;
}
37c34: 13e00000 mvnne r0, #0 <== NOT EXECUTED
37c38: e28dd008 add sp, sp, #8 <== NOT EXECUTED
37c3c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00036e1c <msdos_shut_down>:
* RC_OK on success, or -1 if error occured (errno set apropriately).
*
*/
int
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
36e1c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = temp_mt_entry->fs_info;
fat_file_fd_t *fat_fd = temp_mt_entry->mt_fs_root.node_access;
/* close fat-file which correspondes to root directory */
if (fat_file_close(temp_mt_entry, fat_fd) != RC_OK)
36e20: e590101c ldr r1, [r0, #28] <== NOT EXECUTED
* RC_OK on success, or -1 if error occured (errno set apropriately).
*
*/
int
msdos_shut_down(rtems_filesystem_mount_table_entry_t *temp_mt_entry)
{
36e24: e1a04000 mov r4, r0 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = temp_mt_entry->fs_info;
36e28: e5905034 ldr r5, [r0, #52] ; 0x34 <== NOT EXECUTED
fat_file_fd_t *fat_fd = temp_mt_entry->mt_fs_root.node_access;
/* close fat-file which correspondes to root directory */
if (fat_file_close(temp_mt_entry, fat_fd) != RC_OK)
36e2c: ebffbb49 bl 25b58 <fat_file_close> <== NOT EXECUTED 36e30: e2506000 subs r6, r0, #0 <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
}
if (fat_shutdown_drive(temp_mt_entry) != RC_OK)
36e34: e1a00004 mov r0, r4 <== NOT EXECUTED
int rc = RC_OK;
msdos_fs_info_t *fs_info = temp_mt_entry->fs_info;
fat_file_fd_t *fat_fd = temp_mt_entry->mt_fs_root.node_access;
/* close fat-file which correspondes to root directory */
if (fat_file_close(temp_mt_entry, fat_fd) != RC_OK)
36e38: 13e06000 mvnne r6, #0 <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
}
if (fat_shutdown_drive(temp_mt_entry) != RC_OK)
36e3c: ebffbd85 bl 26458 <fat_shutdown_drive> <== NOT EXECUTED 36e40: e3500000 cmp r0, #0 <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
}
rtems_semaphore_delete(fs_info->vol_sema);
36e44: e5950094 ldr r0, [r5, #148] ; 0x94 <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
}
if (fat_shutdown_drive(temp_mt_entry) != RC_OK)
36e48: 13e06000 mvnne r6, #0 <== NOT EXECUTED
{
/* no return - try to free as much as possible */
rc = -1;
}
rtems_semaphore_delete(fs_info->vol_sema);
36e4c: ebff5559 bl c3b8 <rtems_semaphore_delete> <== NOT EXECUTED
free(fs_info->cl_buf);
36e50: e5950098 ldr r0, [r5, #152] ; 0x98 <== NOT EXECUTED 36e54: ebff43c5 bl 7d70 <free> <== NOT EXECUTED
free(temp_mt_entry->fs_info);
36e58: e5940034 ldr r0, [r4, #52] ; 0x34 <== NOT EXECUTED 36e5c: ebff43c3 bl 7d70 <free> <== NOT EXECUTED
return rc;
}
36e60: e1a00006 mov r0, r6 <== NOT EXECUTED
36e64: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00002a7c <newlib_free_buffers>:
*/
int newlib_free_buffers(
FILE *fp
)
{
2a7c: e92d4010 push {r4, lr}
2a80: e1a04000 mov r4, r0
switch ( fileno(fp) ) {
2a84: eb002f0c bl e6bc <fileno>
2a88: e3500002 cmp r0, #2
2a8c: 9a000003 bls 2aa0 <newlib_free_buffers+0x24>
fp->_flags &= ~__SMBF;
fp->_bf._base = fp->_p = (unsigned char *) NULL;
}
break;
default:
fclose(fp);
2a90: e1a00004 mov r0, r4 <== NOT EXECUTED
2a94: eb002e56 bl e3f4 <fclose> <== NOT EXECUTED
} return 0; }
2a98: e3a00000 mov r0, #0
2a9c: e8bd8010 pop {r4, pc}
{
switch ( fileno(fp) ) {
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
2aa0: e1d430bc ldrh r3, [r4, #12]
2aa4: e3130080 tst r3, #128 ; 0x80
2aa8: 0afffffa beq 2a98 <newlib_free_buffers+0x1c>
free( fp->_bf._base );
2aac: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
2ab0: ebfffd7c bl 20a8 <free> <== NOT EXECUTED
fp->_flags &= ~__SMBF;
2ab4: e1d420bc ldrh r2, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2ab8: e3a03000 mov r3, #0 <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
2abc: e3c22080 bic r2, r2, #128 ; 0x80 <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2ac0: e5843010 str r3, [r4, #16] <== NOT EXECUTED
case 0:
case 1:
case 2:
if (fp->_flags & __SMBF) {
free( fp->_bf._base );
fp->_flags &= ~__SMBF;
2ac4: e1c420bc strh r2, [r4, #12] <== NOT EXECUTED
fp->_bf._base = fp->_p = (unsigned char *) NULL;
2ac8: e5843000 str r3, [r4] <== NOT EXECUTED
break;
default:
fclose(fp);
}
return 0;
}
2acc: e3a00000 mov r0, #0 <== NOT EXECUTED
2ad0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00002558 <null_initialize>:
rtems_device_driver null_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *pargp __attribute__((unused))
)
{
2558: e92d4010 push {r4, lr}
rtems_device_driver status;
if ( !initialized ) {
255c: e59f3044 ldr r3, [pc, #68] ; 25a8 <null_initialize+0x50>
2560: e5d32000 ldrb r2, [r3]
2564: e3520000 cmp r2, #0
rtems_device_driver null_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *pargp __attribute__((unused))
)
{
2568: e1a04000 mov r4, r0
rtems_device_driver status;
if ( !initialized ) {
256c: 0a000001 beq 2578 <null_initialize+0x20>
NULL_major = major;
}
return RTEMS_SUCCESSFUL;
}
2570: e3a00000 mov r0, #0
2574: e8bd8010 pop {r4, pc}
)
{
rtems_device_driver status;
if ( !initialized ) {
initialized = 1;
2578: e3a0c001 mov ip, #1
status = rtems_io_register_name(
257c: e59f0028 ldr r0, [pc, #40] ; 25ac <null_initialize+0x54>
2580: e1a01004 mov r1, r4
)
{
rtems_device_driver status;
if ( !initialized ) {
initialized = 1;
2584: e5c3c000 strb ip, [r3]
status = rtems_io_register_name(
2588: eb0001b7 bl 2c6c <rtems_io_register_name>
"/dev/null",
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
258c: e3500000 cmp r0, #0
2590: 1a000003 bne 25a4 <null_initialize+0x4c>
rtems_fatal_error_occurred(status);
NULL_major = major;
2594: e59f3014 ldr r3, [pc, #20] ; 25b0 <null_initialize+0x58>
}
return RTEMS_SUCCESSFUL;
}
2598: e3a00000 mov r0, #0
);
if (status != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(status);
NULL_major = major;
259c: e5834000 str r4, [r3]
}
return RTEMS_SUCCESSFUL;
}
25a0: e8bd8010 pop {r4, pc}
major,
(rtems_device_minor_number) 0
);
if (status != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(status);
25a4: eb001286 bl 6fc4 <rtems_fatal_error_occurred> <== NOT EXECUTED
00002d14 <open>:
int open(
const char *pathname,
int flags,
...
)
{
2d14: e92d000e push {r1, r2, r3}
2d18: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
2d1c: e24dd01c sub sp, sp, #28
2d20: e59d503c ldr r5, [sp, #60] ; 0x3c
/*
* Set the Evaluation flags
*/
eval_flags = 0;
status = flags + 1;
2d24: e2853001 add r3, r5, #1
if ( ( status & _FREAD ) == _FREAD )
2d28: e2138001 ands r8, r3, #1
2d2c: 13a08004 movne r8, #4
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
2d30: e3130002 tst r3, #2
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
va_start(ap, flags);
mode = va_arg( ap, int );
2d34: e28d3044 add r3, sp, #68 ; 0x44
int open(
const char *pathname,
int flags,
...
)
{
2d38: e1a06000 mov r6, r0
eval_flags = 0;
status = flags + 1;
if ( ( status & _FREAD ) == _FREAD )
eval_flags |= RTEMS_LIBIO_PERMS_READ;
if ( ( status & _FWRITE ) == _FWRITE )
eval_flags |= RTEMS_LIBIO_PERMS_WRITE;
2d3c: 13888002 orrne r8, r8, #2
va_start(ap, flags);
mode = va_arg( ap, int );
2d40: e58d3018 str r3, [sp, #24]
2d44: e59da040 ldr sl, [sp, #64] ; 0x40
* code does not require changes here since network file
* descriptors are obtained using socket(), not open().
*/
/* allocate a file control block */
iop = rtems_libio_allocate();
2d48: eb002073 bl af1c <rtems_libio_allocate>
if ( iop == 0 ) {
2d4c: e2504000 subs r4, r0, #0
2d50: 03a06017 moveq r6, #23
2d54: 0a00005d beq 2ed0 <open+0x1bc>
/*
* See if the file exists.
*/
status = rtems_filesystem_evaluate_path(
2d58: e1a00006 mov r0, r6
2d5c: eb00315c bl f2d4 <strlen>
2d60: e28d7004 add r7, sp, #4
2d64: e1a01000 mov r1, r0
2d68: e1a02008 mov r2, r8
2d6c: e1a00006 mov r0, r6
2d70: e3a08001 mov r8, #1
2d74: e1a03007 mov r3, r7
2d78: e58d8000 str r8, [sp]
2d7c: ebfffca7 bl 2020 <rtems_filesystem_evaluate_path>
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
2d80: e3700001 cmn r0, #1
2d84: 0a000055 beq 2ee0 <open+0x1cc>
if ( status != 0 ) { /* The file did not exist */
rc = EACCES;
goto done;
}
} else if ((flags & (O_EXCL|O_CREAT)) == (O_EXCL|O_CREAT)) {
2d88: e2053c0a and r3, r5, #2560 ; 0xa00
2d8c: e3530c0a cmp r3, #2560 ; 0xa00
2d90: 03a06011 moveq r6, #17
2d94: 0a000040 beq 2e9c <open+0x188>
/*
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
2d98: e59d300c ldr r3, [sp, #12]
2d9c: e584303c str r3, [r4, #60] ; 0x3c
iop->file_info = loc.node_access;
2da0: e59d3004 ldr r3, [sp, #4]
iop->flags |= rtems_libio_fcntl_flags( flags );
2da4: e1a00005 mov r0, r5
* Fill in the file control block based on the loc structure
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
iop->file_info = loc.node_access;
2da8: e5843038 str r3, [r4, #56] ; 0x38
iop->flags |= rtems_libio_fcntl_flags( flags );
2dac: e5948014 ldr r8, [r4, #20]
2db0: eb002087 bl afd4 <rtems_libio_fcntl_flags>
iop->pathinfo = loc;
2db4: e1a0e007 mov lr, r7
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
iop->file_info = loc.node_access;
iop->flags |= rtems_libio_fcntl_flags( flags );
2db8: e1808008 orr r8, r0, r8
iop->pathinfo = loc;
2dbc: e8be000f ldm lr!, {r0, r1, r2, r3}
2dc0: e284c018 add ip, r4, #24
2dc4: e8ac000f stmia ip!, {r0, r1, r2, r3}
if ( !iop->handlers || !iop->handlers->open_h ) {
2dc8: e594303c ldr r3, [r4, #60] ; 0x3c
*/
iop->handlers = loc.handlers;
iop->file_info = loc.node_access;
iop->flags |= rtems_libio_fcntl_flags( flags );
iop->pathinfo = loc;
2dcc: e59e2000 ldr r2, [lr]
if ( !iop->handlers || !iop->handlers->open_h ) {
2dd0: e3530000 cmp r3, #0
*/
iop->handlers = loc.handlers;
iop->file_info = loc.node_access;
iop->flags |= rtems_libio_fcntl_flags( flags );
iop->pathinfo = loc;
2dd4: e58c2000 str r2, [ip]
* returned by successful path evaluation.
*/
iop->handlers = loc.handlers;
iop->file_info = loc.node_access;
iop->flags |= rtems_libio_fcntl_flags( flags );
2dd8: e5848014 str r8, [r4, #20]
iop->pathinfo = loc;
if ( !iop->handlers || !iop->handlers->open_h ) {
2ddc: 0a00002d beq 2e98 <open+0x184>
2de0: e593c000 ldr ip, [r3]
2de4: e35c0000 cmp ip, #0
2de8: 0a00002a beq 2e98 <open+0x184>
rc = ENOTSUP;
goto done;
}
rc = (*iop->handlers->open_h)( iop, pathname, flags, mode );
2dec: e1a01006 mov r1, r6
2df0: e1a0300a mov r3, sl
2df4: e1a00004 mov r0, r4
2df8: e1a02005 mov r2, r5
2dfc: e1a0e00f mov lr, pc
2e00: e12fff1c bx ip
if ( rc ) {
2e04: e3500000 cmp r0, #0
2e08: 1a000009 bne 2e34 <open+0x120>
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
2e0c: e3150b01 tst r5, #1024 ; 0x400
2e10: 1a00000c bne 2e48 <open+0x134>
2e14: e59f5150 ldr r5, [pc, #336] ; 2f6c <open+0x258>
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
}
return iop - rtems_libio_iops;
2e18: e5950000 ldr r0, [r5]
2e1c: e0604004 rsb r4, r0, r4
2e20: e1a00344 asr r0, r4, #6
}
2e24: e28dd01c add sp, sp, #28
2e28: e8bd47f0 pop {r4, r5, r6, r7, r8, r9, sl, lr}
2e2c: e28dd00c add sp, sp, #12
2e30: e12fff1e bx lr
goto done;
}
rc = (*iop->handlers->open_h)( iop, pathname, flags, mode );
if ( rc ) {
rc = errno;
2e34: eb002d21 bl e2c0 <__errno>
2e38: e5906000 ldr r6, [r0]
*/
done:
va_end(ap);
if ( rc ) {
2e3c: e3560000 cmp r6, #0
2e40: 0afffff3 beq 2e14 <open+0x100>
2e44: ea000014 b 2e9c <open+0x188>
/*
* Optionally truncate the file.
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
2e48: e59f511c ldr r5, [pc, #284] ; 2f6c <open+0x258>
2e4c: e5950000 ldr r0, [r5]
2e50: e0600004 rsb r0, r0, r4
2e54: e1a00340 asr r0, r0, #6
2e58: e3a01000 mov r1, #0
2e5c: e3a02000 mov r2, #0
2e60: eb001f77 bl ac44 <ftruncate>
if ( rc ) {
2e64: e2506000 subs r6, r0, #0
2e68: 0affffea beq 2e18 <open+0x104>
if(errno) rc = errno;
2e6c: eb002d13 bl e2c0 <__errno> <== NOT EXECUTED
2e70: e5903000 ldr r3, [r0] <== NOT EXECUTED
2e74: e3530000 cmp r3, #0 <== NOT EXECUTED
2e78: 1a000038 bne 2f60 <open+0x24c> <== NOT EXECUTED
close( iop - rtems_libio_iops );
2e7c: e5950000 ldr r0, [r5] <== NOT EXECUTED
2e80: e0600004 rsb r0, r0, r4 <== NOT EXECUTED
2e84: e1a00340 asr r0, r0, #6 <== NOT EXECUTED
2e88: e3a04000 mov r4, #0 <== NOT EXECUTED
2e8c: eb001f43 bl aba0 <close> <== NOT EXECUTED
2e90: e1a07004 mov r7, r4 <== NOT EXECUTED
2e94: eaffffe8 b 2e3c <open+0x128> <== NOT EXECUTED
if ( loc_to_free )
rtems_filesystem_freenode( loc_to_free );
rtems_set_errno_and_return_minus_one( rc );
}
return iop - rtems_libio_iops;
2e98: e3a06086 mov r6, #134 ; 0x86 <== NOT EXECUTED
done:
va_end(ap);
if ( rc ) {
if ( iop )
2e9c: e3540000 cmp r4, #0
rtems_libio_free( iop );
2ea0: 11a00004 movne r0, r4
2ea4: 1b002006 blne aec4 <rtems_libio_free>
if ( loc_to_free )
2ea8: e3570000 cmp r7, #0
2eac: 0a000007 beq 2ed0 <open+0x1bc>
rtems_filesystem_freenode( loc_to_free );
2eb0: e597300c ldr r3, [r7, #12]
2eb4: e3530000 cmp r3, #0
2eb8: 0a000004 beq 2ed0 <open+0x1bc>
2ebc: e593301c ldr r3, [r3, #28]
2ec0: e3530000 cmp r3, #0
2ec4: 11a00007 movne r0, r7
2ec8: 11a0e00f movne lr, pc
2ecc: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( rc );
2ed0: eb002cfa bl e2c0 <__errno>
2ed4: e5806000 str r6, [r0]
2ed8: e3e00000 mvn r0, #0
2edc: eaffffd0 b 2e24 <open+0x110>
status = rtems_filesystem_evaluate_path(
pathname, strlen( pathname ), eval_flags, &loc, true );
if ( status == -1 ) {
if ( errno != ENOENT ) {
2ee0: eb002cf6 bl e2c0 <__errno>
2ee4: e5903000 ldr r3, [r0]
2ee8: e3530002 cmp r3, #2
2eec: 0a000003 beq 2f00 <open+0x1ec>
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
if ( rc ) {
rc = errno;
2ef0: eb002cf2 bl e2c0 <__errno>
2ef4: e3a07000 mov r7, #0
2ef8: e5906000 ldr r6, [r0]
goto done;
2efc: eaffffce b 2e3c <open+0x128>
rc = errno;
goto done;
}
/* If the file does not exist and we are not trying to create it--> error */
if ( !(flags & O_CREAT) ) {
2f00: e2159c02 ands r9, r5, #512 ; 0x200
2f04: 01a07009 moveq r7, r9
2f08: 01a06003 moveq r6, r3
2f0c: 0affffe2 beq 2e9c <open+0x188>
rc = ENOENT;
goto done;
}
/* Create the node for the new regular file */
rc = mknod( pathname, S_IFREG | mode, 0LL );
2f10: e1a00006 mov r0, r6
2f14: e38a1902 orr r1, sl, #32768 ; 0x8000
2f18: e3a02000 mov r2, #0
2f1c: e3a03000 mov r3, #0
2f20: ebfffd7c bl 2518 <mknod>
if ( rc ) {
2f24: e2509000 subs r9, r0, #0
2f28: 1afffff0 bne 2ef0 <open+0x1dc>
rc = errno;
goto done;
}
/* Sanity check to see if the file name exists after the mknod() */
status = rtems_filesystem_evaluate_path( pathname, strlen( pathname ), 0x0, &loc, true );
2f2c: e1a00006 mov r0, r6
2f30: eb0030e7 bl f2d4 <strlen>
2f34: e1a03007 mov r3, r7
2f38: e1a01000 mov r1, r0
2f3c: e1a02009 mov r2, r9
2f40: e1a00006 mov r0, r6
2f44: e58d8000 str r8, [sp]
2f48: ebfffc34 bl 2020 <rtems_filesystem_evaluate_path>
if ( status != 0 ) { /* The file did not exist */
2f4c: e3500000 cmp r0, #0
2f50: 11a07009 movne r7, r9
2f54: 13a0600d movne r6, #13
2f58: 1affffcf bne 2e9c <open+0x188>
2f5c: eaffff8d b 2d98 <open+0x84>
*/
if ( (flags & O_TRUNC) == O_TRUNC ) {
rc = ftruncate( iop - rtems_libio_iops, 0 );
if ( rc ) {
if(errno) rc = errno;
2f60: eb002cd6 bl e2c0 <__errno> <== NOT EXECUTED
2f64: e5906000 ldr r6, [r0] <== NOT EXECUTED
2f68: eaffffc3 b 2e7c <open+0x168> <== NOT EXECUTED
00002cac <open_dev_console>:
int stderr_fd;
/*
* Attempt to open /dev/console.
*/
if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) {
2cac: e3a01000 mov r1, #0
/*
* This is a replaceable stub which opens the console, if present.
*/
void open_dev_console(void)
{
2cb0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
int stderr_fd;
/*
* Attempt to open /dev/console.
*/
if ((stdin_fd = open("/dev/console", O_RDONLY, 0)) == -1) {
2cb4: e59f004c ldr r0, [pc, #76] ; 2d08 <open_dev_console+0x5c>
2cb8: e1a02001 mov r2, r1
2cbc: eb000014 bl 2d14 <open>
2cc0: e3700001 cmn r0, #1
2cc4: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
/*
* But if we find /dev/console once, we better find it twice more
* or something is REALLY wrong.
*/
if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1)
2cc8: e59f0038 ldr r0, [pc, #56] ; 2d08 <open_dev_console+0x5c>
2ccc: e3a01001 mov r1, #1
2cd0: e3a02000 mov r2, #0
2cd4: eb00000e bl 2d14 <open>
2cd8: e3700001 cmn r0, #1
2cdc: 0a000007 beq 2d00 <open_dev_console+0x54>
rtems_fatal_error_occurred( 0x55544431 ); /* error STD1 */
if ((stderr_fd = open("/dev/console", O_WRONLY, 0)) == -1)
2ce0: e59f0020 ldr r0, [pc, #32] ; 2d08 <open_dev_console+0x5c>
2ce4: e3a01001 mov r1, #1
2ce8: e3a02000 mov r2, #0
2cec: eb000008 bl 2d14 <open>
2cf0: e3700001 cmn r0, #1
2cf4: 149df004 popne {pc} ; (ldrne pc, [sp], #4)
rtems_fatal_error_occurred( 0x55544432 ); /* error STD2 */
2cf8: e59f000c ldr r0, [pc, #12] ; 2d0c <open_dev_console+0x60> <== NOT EXECUTED
2cfc: eb000c37 bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
/*
* But if we find /dev/console once, we better find it twice more
* or something is REALLY wrong.
*/
if ((stdout_fd = open("/dev/console", O_WRONLY, 0)) == -1)
rtems_fatal_error_occurred( 0x55544431 ); /* error STD1 */
2d00: e59f0008 ldr r0, [pc, #8] ; 2d10 <open_dev_console+0x64> <== NOT EXECUTED
2d04: eb000c35 bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000372c <oproc>:
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
372c: e92d4010 push {r4, lr}
int i;
if (tty->termios.c_oflag & OPOST) {
3730: e5913034 ldr r3, [r1, #52] ; 0x34
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
3734: e24dd004 sub sp, sp, #4
int i;
if (tty->termios.c_oflag & OPOST) {
3738: e3130001 tst r3, #1
/*
* Handle output processing
*/
static void
oproc (unsigned char c, struct rtems_termios_tty *tty)
{
373c: e1a04001 mov r4, r1
3740: e5cd0000 strb r0, [sp]
int i;
if (tty->termios.c_oflag & OPOST) {
3744: 0a000014 beq 379c <oproc+0x70>
switch (c) {
3748: e5dd1000 ldrb r1, [sp]
374c: e2412008 sub r2, r1, #8
3750: e3520005 cmp r2, #5
3754: 979ff102 ldrls pc, [pc, r2, lsl #2]
3758: ea000005 b 3774 <oproc+0x48>
375c: 0000380c .word 0x0000380c
3760: 000037e8 .word 0x000037e8
3764: 00003820 .word 0x00003820
3768: 00003774 .word 0x00003774
376c: 00003774 .word 0x00003774
3770: 000037b4 .word 0x000037b4
if (tty->column > 0)
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
3774: e3130002 tst r3, #2
3778: 1a000034 bne 3850 <oproc+0x124>
377c: e59f310c ldr r3, [pc, #268] ; 3890 <oproc+0x164>
3780: e5933000 ldr r3, [r3]
c = toupper(c); if (!iscntrl(c))
3784: e0831001 add r1, r3, r1
3788: e5d13001 ldrb r3, [r1, #1]
378c: e3130020 tst r3, #32
tty->column++;
3790: 05943028 ldreq r3, [r4, #40] ; 0x28
3794: 02833001 addeq r3, r3, #1
3798: 05843028 streq r3, [r4, #40] ; 0x28
break; } } rtems_termios_puts (&c, 1, tty);
379c: e1a02004 mov r2, r4
37a0: e1a0000d mov r0, sp
37a4: e3a01001 mov r1, #1
37a8: ebffff97 bl 360c <rtems_termios_puts>
}
37ac: e28dd004 add sp, sp, #4
37b0: e8bd8010 pop {r4, pc}
tty->column = 0;
}
break;
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
37b4: e3130010 tst r3, #16 <== NOT EXECUTED
37b8: 0a000002 beq 37c8 <oproc+0x9c> <== NOT EXECUTED
37bc: e5942028 ldr r2, [r4, #40] ; 0x28 <== NOT EXECUTED
37c0: e3520000 cmp r2, #0 <== NOT EXECUTED
37c4: 0afffff8 beq 37ac <oproc+0x80> <== NOT EXECUTED
return;
if (tty->termios.c_oflag & OCRNL) {
37c8: e2132008 ands r2, r3, #8 <== NOT EXECUTED
37cc: 0a00000c beq 3804 <oproc+0xd8> <== NOT EXECUTED
c = '\n'; if (tty->termios.c_oflag & ONLRET)
37d0: e3130020 tst r3, #32 <== NOT EXECUTED
case '\r':
if ((tty->termios.c_oflag & ONOCR) && (tty->column == 0))
return;
if (tty->termios.c_oflag & OCRNL) {
c = '\n';
37d4: e3a0300a mov r3, #10 <== NOT EXECUTED
37d8: e5cd3000 strb r3, [sp] <== NOT EXECUTED
if (tty->termios.c_oflag & ONLRET) tty->column = 0;
37dc: 13a03000 movne r3, #0 <== NOT EXECUTED
37e0: 15843028 strne r3, [r4, #40] ; 0x28 <== NOT EXECUTED
37e4: eaffffec b 379c <oproc+0x70> <== NOT EXECUTED
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
37e8: e5942028 ldr r2, [r4, #40] ; 0x28
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
37ec: e2033b06 and r3, r3, #6144 ; 0x1800
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
37f0: e2021007 and r1, r2, #7
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
37f4: e3530b06 cmp r3, #6144 ; 0x1800
}
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
37f8: e2611008 rsb r1, r1, #8
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
rtems_termios_puts ( " ", i, tty);
return;
}
tty->column += i;
37fc: 10812002 addne r2, r1, r2
tty->column = 0;
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
3800: 0a00001c beq 3878 <oproc+0x14c>
tty->column += i;
rtems_termios_puts ( " ", i, tty);
return;
}
tty->column += i;
3804: e5842028 str r2, [r4, #40] ; 0x28 <== NOT EXECUTED
break;
3808: eaffffe3 b 379c <oproc+0x70> <== NOT EXECUTED
case '\b':
if (tty->column > 0)
380c: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
3810: e3530000 cmp r3, #0 <== NOT EXECUTED
tty->column--;
3814: c2433001 subgt r3, r3, #1 <== NOT EXECUTED
3818: c5843028 strgt r3, [r4, #40] ; 0x28 <== NOT EXECUTED
381c: eaffffde b 379c <oproc+0x70> <== NOT EXECUTED
int i;
if (tty->termios.c_oflag & OPOST) {
switch (c) {
case '\n':
if (tty->termios.c_oflag & ONLRET)
3820: e3130020 tst r3, #32
tty->column = 0;
3824: 13a02000 movne r2, #0
3828: 15842028 strne r2, [r4, #40] ; 0x28
if (tty->termios.c_oflag & ONLCR) {
382c: e3130004 tst r3, #4
3830: 0affffd9 beq 379c <oproc+0x70>
rtems_termios_puts ("\r", 1, tty);
3834: e59f0058 ldr r0, [pc, #88] ; 3894 <oproc+0x168>
3838: e3a01001 mov r1, #1
383c: e1a02004 mov r2, r4
3840: ebffff71 bl 360c <rtems_termios_puts>
tty->column = 0;
3844: e3a03000 mov r3, #0
3848: e5843028 str r3, [r4, #40] ; 0x28
384c: eaffffd2 b 379c <oproc+0x70>
tty->column--;
break;
default:
if (tty->termios.c_oflag & OLCUC)
c = toupper(c);
3850: e59f3038 ldr r3, [pc, #56] ; 3890 <oproc+0x164> <== NOT EXECUTED
3854: e5933000 ldr r3, [r3] <== NOT EXECUTED
3858: e0832001 add r2, r3, r1 <== NOT EXECUTED
385c: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED
3860: e2022003 and r2, r2, #3 <== NOT EXECUTED
3864: e3520002 cmp r2, #2 <== NOT EXECUTED
3868: 02411020 subeq r1, r1, #32 <== NOT EXECUTED
386c: e20110ff and r1, r1, #255 ; 0xff <== NOT EXECUTED
3870: e5cd1000 strb r1, [sp] <== NOT EXECUTED
3874: eaffffc2 b 3784 <oproc+0x58> <== NOT EXECUTED
break;
case '\t':
i = 8 - (tty->column & 7);
if ((tty->termios.c_oflag & TABDLY) == XTABS) {
tty->column += i;
3878: e0812002 add r2, r1, r2
387c: e5842028 str r2, [r4, #40] ; 0x28
rtems_termios_puts ( " ", i, tty);
3880: e59f0010 ldr r0, [pc, #16] ; 3898 <oproc+0x16c>
3884: e1a02004 mov r2, r4
3888: ebffff5f bl 360c <rtems_termios_puts>
return;
388c: eaffffc6 b 37ac <oproc+0x80>
0000d330 <pipe_create>:
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
d330: e92d4070 push {r4, r5, r6, lr}
d334: e24dd028 sub sp, sp, #40 ; 0x28
rtems_filesystem_location_info_t loc;
rtems_libio_t *iop;
int err = 0;
/* Create /tmp if not exists */
if (rtems_filesystem_evaluate_path("/tmp", 3, RTEMS_LIBIO_PERMS_RWX, &loc, TRUE)
d338: e28d4004 add r4, sp, #4
d33c: e3a0c001 mov ip, #1
* Called by pipe() to create an anonymous pipe.
*/
int pipe_create(
int filsdes[2]
)
{
d340: e1a05000 mov r5, r0
rtems_filesystem_location_info_t loc;
rtems_libio_t *iop;
int err = 0;
/* Create /tmp if not exists */
if (rtems_filesystem_evaluate_path("/tmp", 3, RTEMS_LIBIO_PERMS_RWX, &loc, TRUE)
d344: e3a01003 mov r1, #3
d348: e59f0154 ldr r0, [pc, #340] ; d4a4 <pipe_create+0x174>
d34c: e3a02007 mov r2, #7
d350: e1a03004 mov r3, r4
d354: e58dc000 str ip, [sp]
d358: ebffd330 bl 2020 <rtems_filesystem_evaluate_path>
d35c: e3500000 cmp r0, #0
d360: 1a00003a bne d450 <pipe_create+0x120>
return -1;
if (mkdir("/tmp", S_IRWXU|S_IRWXG|S_IRWXO|S_ISVTX) != 0)
return -1;
}
else
rtems_filesystem_freenode(&loc);
d364: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
d368: e3530000 cmp r3, #0 <== NOT EXECUTED
d36c: 0a000004 beq d384 <pipe_create+0x54> <== NOT EXECUTED
d370: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
d374: e3530000 cmp r3, #0 <== NOT EXECUTED
d378: 11a00004 movne r0, r4 <== NOT EXECUTED
d37c: 11a0e00f movne lr, pc <== NOT EXECUTED
d380: 112fff13 bxne r3 <== NOT EXECUTED
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
d384: e59f311c ldr r3, [pc, #284] ; d4a8 <pipe_create+0x178>
d388: e28d4018 add r4, sp, #24
d38c: e8930007 ldm r3, {r0, r1, r2}
d390: e1a0c004 mov ip, r4
d394: e8ac0003 stmia ip!, {r0, r1}
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
d398: e59f310c ldr r3, [pc, #268] ; d4ac <pipe_create+0x17c>
else
rtems_filesystem_freenode(&loc);
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
d39c: e1a0100c mov r1, ip
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
d3a0: e1d3c0b0 ldrh ip, [r3]
else
rtems_filesystem_freenode(&loc);
/* /tmp/.fifoXXXX */
char fifopath[15];
memcpy(fifopath, "/tmp/.fifo", 10);
d3a4: e1c120b0 strh r2, [r1]
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
d3a8: e1a0200c mov r2, ip
d3ac: e28cc001 add ip, ip, #1
d3b0: e59f10f8 ldr r1, [pc, #248] ; d4b0 <pipe_create+0x180>
d3b4: e1c3c0b0 strh ip, [r3]
d3b8: e284000a add r0, r4, #10
d3bc: eb000673 bl ed90 <sprintf>
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
d3c0: e1a00004 mov r0, r4
d3c4: e3a01d06 mov r1, #384 ; 0x180
d3c8: eb0001d3 bl db1c <mkfifo>
d3cc: e2506000 subs r6, r0, #0
d3d0: 1a00001c bne d448 <pipe_create+0x118>
return -1;
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
d3d4: e1a00004 mov r0, r4
d3d8: e3a01901 mov r1, #16384 ; 0x4000
d3dc: ebffd64c bl 2d14 <open>
if (filsdes[0] < 0) {
d3e0: e3500000 cmp r0, #0
return -1;
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
d3e4: e5850000 str r0, [r5]
if (filsdes[0] < 0) {
d3e8: ba000023 blt d47c <pipe_create+0x14c>
the file node will be deleted after it is closed by all. */
unlink(fifopath);
}
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
d3ec: e59f30c0 ldr r3, [pc, #192] ; d4b4 <pipe_create+0x184> <== NOT EXECUTED
d3f0: e5933000 ldr r3, [r3] <== NOT EXECUTED
d3f4: e1500003 cmp r0, r3 <== NOT EXECUTED
d3f8: 359f30b8 ldrcc r3, [pc, #184] ; d4b8 <pipe_create+0x188> <== NOT EXECUTED
d3fc: 35936000 ldrcc r6, [r3] <== NOT EXECUTED
d400: 30866300 addcc r6, r6, r0, lsl #6 <== NOT EXECUTED
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
d404: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
d408: e3c33001 bic r3, r3, #1 <== NOT EXECUTED
d40c: e5863014 str r3, [r6, #20] <== NOT EXECUTED
filsdes[1] = open(fifopath, O_WRONLY);
d410: e1a00004 mov r0, r4 <== NOT EXECUTED
d414: e3a01001 mov r1, #1 <== NOT EXECUTED
d418: ebffd63d bl 2d14 <open> <== NOT EXECUTED
if (filsdes[1] < 0) {
d41c: e3500000 cmp r0, #0 <== NOT EXECUTED
else {
/* Reset open file to blocking mode */
iop = rtems_libio_iop(filsdes[0]);
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
d420: e5850004 str r0, [r5, #4] <== NOT EXECUTED
if (filsdes[1] < 0) {
d424: a3a06000 movge r6, #0 <== NOT EXECUTED
d428: ba000018 blt d490 <pipe_create+0x160> <== NOT EXECUTED
err = errno;
close(filsdes[0]);
}
unlink(fifopath);
d42c: e1a00004 mov r0, r4 <== NOT EXECUTED
d430: eb0001bd bl db2c <unlink> <== NOT EXECUTED
}
rtems_set_errno_and_return_minus_one(err);
d434: eb0003a1 bl e2c0 <__errno>
d438: e5806000 str r6, [r0]
}
d43c: e3e00000 mvn r0, #0
d440: e28dd028 add sp, sp, #40 ; 0x28
d444: e8bd8070 pop {r4, r5, r6, pc}
memcpy(fifopath, "/tmp/.fifo", 10);
sprintf(fifopath + 10, "%04x", rtems_pipe_no ++);
/* Try creating FIFO file until find an available file name */
while (mkfifo(fifopath, S_IRUSR|S_IWUSR) != 0) {
if (errno != EEXIST){
d448: eb00039c bl e2c0 <__errno> <== NOT EXECUTED
d44c: eafffffa b d43c <pipe_create+0x10c> <== NOT EXECUTED
rtems_libio_t *iop;
int err = 0;
/* Create /tmp if not exists */
if (rtems_filesystem_evaluate_path("/tmp", 3, RTEMS_LIBIO_PERMS_RWX, &loc, TRUE)
!= 0) {
if (errno != ENOENT)
d450: eb00039a bl e2c0 <__errno>
d454: e5903000 ldr r3, [r0]
d458: e3530002 cmp r3, #2
d45c: 1afffff6 bne d43c <pipe_create+0x10c>
return -1;
if (mkdir("/tmp", S_IRWXU|S_IRWXG|S_IRWXO|S_ISVTX) != 0)
d460: e3a01fff mov r1, #1020 ; 0x3fc
d464: e2811003 add r1, r1, #3
d468: e59f0034 ldr r0, [pc, #52] ; d4a4 <pipe_create+0x174>
d46c: ebffd425 bl 2508 <mkdir>
d470: e3500000 cmp r0, #0
d474: 0affffc2 beq d384 <pipe_create+0x54>
d478: eaffffef b d43c <pipe_create+0x10c> <== NOT EXECUTED
}
/* Non-blocking open to avoid waiting for writers */
filsdes[0] = open(fifopath, O_RDONLY | O_NONBLOCK);
if (filsdes[0] < 0) {
err = errno;
d47c: eb00038f bl e2c0 <__errno>
d480: e5906000 ldr r6, [r0]
/* Delete file at errors, or else if pipe is successfully created
the file node will be deleted after it is closed by all. */
unlink(fifopath);
d484: e1a00004 mov r0, r4
d488: eb0001a7 bl db2c <unlink>
d48c: eaffffe8 b d434 <pipe_create+0x104>
iop->flags &= ~LIBIO_FLAGS_NO_DELAY;
filsdes[1] = open(fifopath, O_WRONLY);
if (filsdes[1] < 0) {
err = errno;
d490: eb00038a bl e2c0 <__errno> <== NOT EXECUTED
d494: e5906000 ldr r6, [r0] <== NOT EXECUTED
close(filsdes[0]);
d498: e5950000 ldr r0, [r5] <== NOT EXECUTED
d49c: ebfff5bf bl aba0 <close> <== NOT EXECUTED
d4a0: eaffffe1 b d42c <pipe_create+0xfc> <== NOT EXECUTED
000090ec <pipe_ioctl>:
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
if (cmd == FIONREAD) {
90ec: e3a03a46 mov r3, #286720 ; 0x46000 <== NOT EXECUTED
90f0: e2833e67 add r3, r3, #1648 ; 0x670 <== NOT EXECUTED
90f4: e283313d add r3, r3, #1073741839 ; 0x4000000f <== NOT EXECUTED
90f8: e1510003 cmp r1, r3 <== NOT EXECUTED
pipe_control_t *pipe,
uint32_t cmd,
void *buffer,
rtems_libio_t *iop
)
{
90fc: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
9100: e1a05000 mov r5, r0 <== NOT EXECUTED
9104: e1a04002 mov r4, r2 <== NOT EXECUTED
if (cmd == FIONREAD) {
9108: 13e00015 mvnne r0, #21 <== NOT EXECUTED
910c: 18bd8070 popne {r4, r5, r6, pc} <== NOT EXECUTED
if (buffer == NULL)
9110: e3520000 cmp r2, #0 <== NOT EXECUTED
9114: 03e0000d mvneq r0, #13 <== NOT EXECUTED
9118: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return -EFAULT;
if (! PIPE_LOCK(pipe))
911c: e3a01000 mov r1, #0 <== NOT EXECUTED
9120: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
9124: e1a02001 mov r2, r1 <== NOT EXECUTED
9128: ebfff19f bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
912c: e2506000 subs r6, r0, #0 <== NOT EXECUTED
9130: 13e00003 mvnne r0, #3 <== NOT EXECUTED
9134: 18bd8070 popne {r4, r5, r6, pc} <== NOT EXECUTED
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
9138: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
913c: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
/* Return length of pipe */
*(unsigned int *)buffer = pipe->Length;
9140: e5843000 str r3, [r4] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
9144: ebfff1e0 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
9148: e1a00006 mov r0, r6 <== NOT EXECUTED
return 0;
}
return -EINVAL;
}
914c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00009074 <pipe_lseek>:
rtems_libio_t *iop
)
{
/* Seek on pipe is not supported */
return -ESPIPE;
}
9074: e3e0001c mvn r0, #28 <== NOT EXECUTED
9078: e12fff1e bx lr <== NOT EXECUTED
00009350 <pipe_read>:
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
9350: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
9354: e1a09001 mov r9, r1 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
9358: e3a01000 mov r1, #0 <== NOT EXECUTED
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
935c: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
9360: e1a04000 mov r4, r0 <== NOT EXECUTED
9364: e1a05002 mov r5, r2 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
9368: e5900028 ldr r0, [r0, #40] ; 0x28 <== NOT EXECUTED
936c: e1a02001 mov r2, r1 <== NOT EXECUTED
pipe_control_t *pipe,
void *buffer,
size_t count,
rtems_libio_t *iop
)
{
9370: e1a08003 mov r8, r3 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
9374: ebfff10c bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
9378: e250a000 subs sl, r0, #0 <== NOT EXECUTED
937c: 13e07003 mvnne r7, #3 <== NOT EXECUTED
9380: 1a000027 bne 9424 <pipe_read+0xd4> <== NOT EXECUTED
return -EINTR;
while (read < count) {
9384: e3550000 cmp r5, #0 <== NOT EXECUTED
9388: 01a07005 moveq r7, r5 <== NOT EXECUTED
938c: 01a06007 moveq r6, r7 <== NOT EXECUTED
9390: 0a00001f beq 9414 <pipe_read+0xc4> <== NOT EXECUTED
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
if (ret != 0)
9394: e1a0700a mov r7, sl <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
9398: e28db004 add fp, sp, #4 <== NOT EXECUTED
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
while (PIPE_EMPTY(pipe)) {
939c: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
93a0: e3520000 cmp r2, #0 <== NOT EXECUTED
93a4: 1a000021 bne 9430 <pipe_read+0xe0> <== NOT EXECUTED
/* Not an error */
if (pipe->Writers == 0)
93a8: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
93ac: e3530000 cmp r3, #0 <== NOT EXECUTED
93b0: 0a00003d beq 94ac <pipe_read+0x15c> <== NOT EXECUTED
goto out_locked;
if (LIBIO_NODELAY(iop)) {
93b4: e5986014 ldr r6, [r8, #20] <== NOT EXECUTED
93b8: e2166001 ands r6, r6, #1 <== NOT EXECUTED
93bc: 1a00003c bne 94b4 <pipe_read+0x164> <== NOT EXECUTED
ret = -EAGAIN;
goto out_locked;
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
93c0: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
93c4: e2833001 add r3, r3, #1 <== NOT EXECUTED
93c8: e5843018 str r3, [r4, #24] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
93cc: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
93d0: ebfff13d bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_READWAIT(pipe))
93d4: e1a01006 mov r1, r6 <== NOT EXECUTED
93d8: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
93dc: eb000823 bl b470 <rtems_barrier_wait> <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
93e0: e1a01006 mov r1, r6 <== NOT EXECUTED
93e4: e1a02001 mov r2, r1 <== NOT EXECUTED
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
93e8: e2506000 subs r6, r0, #0 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
93ec: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
}
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
93f0: 13e06003 mvnne r6, #3 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
93f4: ebfff0ec bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
93f8: e3500000 cmp r0, #0 <== NOT EXECUTED
93fc: 1a00002e bne 94bc <pipe_read+0x16c> <== NOT EXECUTED
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
9400: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
if (ret != 0)
9404: e3560000 cmp r6, #0 <== NOT EXECUTED
if (! PIPE_LOCK(pipe)) {
/* WARN waitingReaders not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingReaders --;
9408: e2433001 sub r3, r3, #1 <== NOT EXECUTED
940c: e5843018 str r3, [r4, #24] <== NOT EXECUTED
if (ret != 0)
9410: 0affffe1 beq 939c <pipe_read+0x4c> <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
}
out_locked:
PIPE_UNLOCK(pipe);
9414: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
9418: ebfff12b bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
out_nolock:
if (read > 0)
941c: e3570000 cmp r7, #0 <== NOT EXECUTED
9420: d1a07006 movle r7, r6 <== NOT EXECUTED
return read;
return ret;
}
9424: e1a00007 mov r0, r7 <== NOT EXECUTED
9428: e28dd008 add sp, sp, #8 <== NOT EXECUTED
942c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
9430: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED
9434: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
if (ret != 0)
goto out_locked;
}
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
9438: e06a6005 rsb r6, sl, r5 <== NOT EXECUTED
943c: e1520006 cmp r2, r6 <== NOT EXECUTED
9440: 31a06002 movcc r6, r2 <== NOT EXECUTED
chunk1 = pipe->Size - pipe->Start;
9444: e0613003 rsb r3, r1, r3 <== NOT EXECUTED
if (chunk > chunk1) {
9448: e1560003 cmp r6, r3 <== NOT EXECUTED
944c: ca00001c bgt 94c4 <pipe_read+0x174> <== NOT EXECUTED
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
9450: e5943000 ldr r3, [r4] <== NOT EXECUTED
9454: e089000a add r0, r9, sl <== NOT EXECUTED
9458: e0831001 add r1, r3, r1 <== NOT EXECUTED
945c: e1a02006 mov r2, r6 <== NOT EXECUTED
9460: eb0015a4 bl eaf8 <memcpy> <== NOT EXECUTED
pipe->Start += chunk;
9464: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
9468: e0860000 add r0, r6, r0 <== NOT EXECUTED
946c: e5840008 str r0, [r4, #8] <== NOT EXECUTED
pipe->Start %= pipe->Size;
9470: e5941004 ldr r1, [r4, #4] <== NOT EXECUTED
9474: eb00395f bl 179f8 <__umodsi3> <== NOT EXECUTED
pipe->Length -= chunk;
9478: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
947c: e0663003 rsb r3, r6, r3 <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
9480: e3530000 cmp r3, #0 <== NOT EXECUTED
}
else
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk);
pipe->Start += chunk;
pipe->Start %= pipe->Size;
9484: e5840008 str r0, [r4, #8] <== NOT EXECUTED
pipe->Length -= chunk;
9488: e584300c str r3, [r4, #12] <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
948c: 05843008 streq r3, [r4, #8] <== NOT EXECUTED
if (pipe->waitingWriters > 0)
9490: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
9494: e3530000 cmp r3, #0 <== NOT EXECUTED
9498: 1a000016 bne 94f8 <pipe_read+0x1a8> <== NOT EXECUTED
PIPE_WAKEUPWRITERS(pipe);
read += chunk;
949c: e0877006 add r7, r7, r6 <== NOT EXECUTED
int chunk, chunk1, read = 0, ret = 0;
if (! PIPE_LOCK(pipe))
return -EINTR;
while (read < count) {
94a0: e1570005 cmp r7, r5 <== NOT EXECUTED
94a4: e1a0a007 mov sl, r7 <== NOT EXECUTED
94a8: 3affffbb bcc 939c <pipe_read+0x4c> <== NOT EXECUTED
94ac: e3a06000 mov r6, #0 <== NOT EXECUTED
94b0: eaffffd7 b 9414 <pipe_read+0xc4> <== NOT EXECUTED
while (PIPE_EMPTY(pipe)) {
/* Not an error */
if (pipe->Writers == 0)
goto out_locked;
if (LIBIO_NODELAY(iop)) {
94b4: e3e0600a mvn r6, #10 <== NOT EXECUTED
94b8: eaffffd5 b 9414 <pipe_read+0xc4> <== NOT EXECUTED
/* Wait until pipe is no more empty or no writer exists */
pipe->waitingReaders ++;
PIPE_UNLOCK(pipe);
if (! PIPE_READWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
94bc: e3e06003 mvn r6, #3 <== NOT EXECUTED
94c0: eaffffd5 b 941c <pipe_read+0xcc> <== NOT EXECUTED
/* Read chunk bytes */
chunk = MIN(count - read, pipe->Length);
chunk1 = pipe->Size - pipe->Start;
if (chunk > chunk1) {
memcpy(buffer + read, pipe->Buffer + pipe->Start, chunk1);
94c4: e5942000 ldr r2, [r4] <== NOT EXECUTED
94c8: e089000a add r0, r9, sl <== NOT EXECUTED
94cc: e0821001 add r1, r2, r1 <== NOT EXECUTED
94d0: e1a02003 mov r2, r3 <== NOT EXECUTED
94d4: e58d3000 str r3, [sp] <== NOT EXECUTED
94d8: eb001586 bl eaf8 <memcpy> <== NOT EXECUTED
memcpy(buffer + read + chunk1, pipe->Buffer, chunk - chunk1);
94dc: e59d3000 ldr r3, [sp] <== NOT EXECUTED
94e0: e08a0003 add r0, sl, r3 <== NOT EXECUTED
94e4: e0890000 add r0, r9, r0 <== NOT EXECUTED
94e8: e0632006 rsb r2, r3, r6 <== NOT EXECUTED
94ec: e5941000 ldr r1, [r4] <== NOT EXECUTED
94f0: eb001580 bl eaf8 <memcpy> <== NOT EXECUTED
94f4: eaffffda b 9464 <pipe_read+0x114> <== NOT EXECUTED
/* For buffering optimization */
if (PIPE_EMPTY(pipe))
pipe->Start = 0;
if (pipe->waitingWriters > 0)
PIPE_WAKEUPWRITERS(pipe);
94f8: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED
94fc: e1a0100b mov r1, fp <== NOT EXECUTED
9500: eb0007c1 bl b40c <rtems_barrier_release> <== NOT EXECUTED
9504: eaffffe4 b 949c <pipe_read+0x14c> <== NOT EXECUTED
00009508 <pipe_release>:
*/
int pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
9508: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
pipe_control_t *pipe = *pipep;
950c: e5904000 ldr r4, [r0] <== NOT EXECUTED
*/
int pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
9510: e1a05001 mov r5, r1 <== NOT EXECUTED
pipe_control_t *pipe = *pipep;
uint32_t mode;
rtems_status_code sc;
sc = rtems_semaphore_obtain(pipe->Semaphore,
9514: e3a01000 mov r1, #0 <== NOT EXECUTED
*/
int pipe_release(
pipe_control_t **pipep,
rtems_libio_t *iop
)
{
9518: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
951c: e1a07000 mov r7, r0 <== NOT EXECUTED
pipe_control_t *pipe = *pipep;
uint32_t mode;
rtems_status_code sc;
sc = rtems_semaphore_obtain(pipe->Semaphore,
9520: e1a02001 mov r2, r1 <== NOT EXECUTED
9524: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
9528: ebfff09f bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
/* WARN pipe not released! */
if(sc != RTEMS_SUCCESSFUL)
952c: e3500000 cmp r0, #0 <== NOT EXECUTED
9530: 1a000038 bne 9618 <pipe_release+0x110> <== NOT EXECUTED
rtems_fatal_error_occurred(sc);
mode = LIBIO_ACCMODE(iop);
9534: e5956014 ldr r6, [r5, #20] <== NOT EXECUTED
if (mode & LIBIO_FLAGS_READ)
9538: e3160002 tst r6, #2 <== NOT EXECUTED
pipe->Readers --;
953c: 15943010 ldrne r3, [r4, #16] <== NOT EXECUTED
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
/* WARN pipe not released! */
if(sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(sc);
mode = LIBIO_ACCMODE(iop);
9540: e2066006 and r6, r6, #6 <== NOT EXECUTED
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
9544: 12433001 subne r3, r3, #1 <== NOT EXECUTED
9548: 15843010 strne r3, [r4, #16] <== NOT EXECUTED
if (mode & LIBIO_FLAGS_WRITE)
954c: e3160004 tst r6, #4 <== NOT EXECUTED
pipe->Writers --;
9550: 15943014 ldrne r3, [r4, #20] <== NOT EXECUTED
sc = rtems_semaphore_obtain(rtems_pipe_semaphore,
9554: e59f50c0 ldr r5, [pc, #192] ; 961c <pipe_release+0x114> <== NOT EXECUTED
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
9558: 12433001 subne r3, r3, #1 <== NOT EXECUTED
sc = rtems_semaphore_obtain(rtems_pipe_semaphore,
955c: e3a01000 mov r1, #0 <== NOT EXECUTED
mode = LIBIO_ACCMODE(iop);
if (mode & LIBIO_FLAGS_READ)
pipe->Readers --;
if (mode & LIBIO_FLAGS_WRITE)
pipe->Writers --;
9560: 15843014 strne r3, [r4, #20] <== NOT EXECUTED
sc = rtems_semaphore_obtain(rtems_pipe_semaphore,
9564: e5950000 ldr r0, [r5] <== NOT EXECUTED
9568: e1a02001 mov r2, r1 <== NOT EXECUTED
956c: ebfff08e bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
/* WARN pipe not freed and pipep not set to NULL! */
if(sc != RTEMS_SUCCESSFUL)
9570: e3500000 cmp r0, #0 <== NOT EXECUTED
9574: 1a000027 bne 9618 <pipe_release+0x110> <== NOT EXECUTED
rtems_fatal_error_occurred(sc);
PIPE_UNLOCK(pipe);
9578: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
957c: ebfff0d2 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
if (pipe->Readers == 0 && pipe->Writers == 0) {
9580: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
9584: e3530000 cmp r3, #0 <== NOT EXECUTED
9588: 0a00000d beq 95c4 <pipe_release+0xbc> <== NOT EXECUTED
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
else if (pipe->Writers == 0 && mode != LIBIO_FLAGS_READ)
958c: e5942014 ldr r2, [r4, #20] <== NOT EXECUTED
9590: e2723001 rsbs r3, r2, #1 <== NOT EXECUTED
9594: 33a03000 movcc r3, #0 <== NOT EXECUTED
9598: e3560002 cmp r6, #2 <== NOT EXECUTED
959c: 03a03000 moveq r3, #0 <== NOT EXECUTED
95a0: e3530000 cmp r3, #0 <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
95a4: 1594002c ldrne r0, [r4, #44] ; 0x2c <== NOT EXECUTED
95a8: 11a0100d movne r1, sp <== NOT EXECUTED
95ac: 1b000796 blne b40c <rtems_barrier_release> <== NOT EXECUTED
rtems_semaphore_release(rtems_pipe_semaphore);
95b0: e5950000 ldr r0, [r5] <== NOT EXECUTED
95b4: ebfff0c4 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
if(iop->pathinfo.ops->unlink_h(&iop->pathinfo))
return -errno;
#endif
return 0;
}
95b8: e3a00000 mov r0, #0 <== NOT EXECUTED
95bc: e28dd004 add sp, sp, #4 <== NOT EXECUTED
95c0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if(sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(sc);
PIPE_UNLOCK(pipe);
if (pipe->Readers == 0 && pipe->Writers == 0) {
95c4: e5948014 ldr r8, [r4, #20] <== NOT EXECUTED
95c8: e3580000 cmp r8, #0 <== NOT EXECUTED
95cc: 0a000005 beq 95e8 <pipe_release+0xe0> <== NOT EXECUTED
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
}
else if (pipe->Readers == 0 && mode != LIBIO_FLAGS_WRITE)
95d0: e3560004 cmp r6, #4 <== NOT EXECUTED
95d4: 0afffff5 beq 95b0 <pipe_release+0xa8> <== NOT EXECUTED
/* Notify waiting Writers that all their partners left */
PIPE_WAKEUPWRITERS(pipe);
95d8: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED
95dc: e1a0100d mov r1, sp <== NOT EXECUTED
95e0: eb000789 bl b40c <rtems_barrier_release> <== NOT EXECUTED
95e4: eafffff1 b 95b0 <pipe_release+0xa8> <== NOT EXECUTED
/* Called with rtems_pipe_semaphore held. */
static inline void pipe_free(
pipe_control_t *pipe
)
{
rtems_barrier_delete(pipe->readBarrier);
95e8: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
95ec: eb00076c bl b3a4 <rtems_barrier_delete> <== NOT EXECUTED
rtems_barrier_delete(pipe->writeBarrier);
95f0: e5940030 ldr r0, [r4, #48] ; 0x30 <== NOT EXECUTED
95f4: eb00076a bl b3a4 <rtems_barrier_delete> <== NOT EXECUTED
rtems_semaphore_delete(pipe->Semaphore);
95f8: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
95fc: ebfff041 bl 5708 <rtems_semaphore_delete> <== NOT EXECUTED
free(pipe->Buffer);
9600: e5940000 ldr r0, [r4] <== NOT EXECUTED
9604: ebffe2a7 bl 20a8 <free> <== NOT EXECUTED
free(pipe);
9608: e1a00004 mov r0, r4 <== NOT EXECUTED
960c: ebffe2a5 bl 20a8 <free> <== NOT EXECUTED
/* To delete an anonymous pipe file when all users closed it */
if (pipe->Anonymous)
delfile = TRUE;
#endif
pipe_free(pipe);
*pipep = NULL;
9610: e5878000 str r8, [r7] <== NOT EXECUTED
if(sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(sc);
PIPE_UNLOCK(pipe);
if (pipe->Readers == 0 && pipe->Writers == 0) {
9614: eaffffe5 b 95b0 <pipe_release+0xa8> <== NOT EXECUTED
sc = rtems_semaphore_obtain(rtems_pipe_semaphore,
RTEMS_WAIT, RTEMS_NO_TIMEOUT);
/* WARN pipe not freed and pipep not set to NULL! */
if(sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred(sc);
9618: ebfff1f0 bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
00009150 <pipe_write>:
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
9150: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
9154: e2524000 subs r4, r2, #0 <== NOT EXECUTED
pipe_control_t *pipe,
const void *buffer,
size_t count,
rtems_libio_t *iop
)
{
9158: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
915c: e1a05000 mov r5, r0 <== NOT EXECUTED
9160: e1a06001 mov r6, r1 <== NOT EXECUTED
int chunk, chunk1, written = 0, ret = 0;
/* Write nothing */
if (count == 0)
9164: 01a07004 moveq r7, r4 <== NOT EXECUTED
9168: 1a000002 bne 9178 <pipe_write+0x28> <== NOT EXECUTED
#endif
if (written > 0)
return written;
return ret;
}
916c: e1a00007 mov r0, r7 <== NOT EXECUTED
9170: e28dd008 add sp, sp, #8 <== NOT EXECUTED
9174: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/* Write nothing */
if (count == 0)
return 0;
if (! PIPE_LOCK(pipe))
9178: e3a01000 mov r1, #0 <== NOT EXECUTED
917c: e5900028 ldr r0, [r0, #40] ; 0x28 <== NOT EXECUTED
9180: e1a02001 mov r2, r1 <== NOT EXECUTED
9184: e58d3000 str r3, [sp] <== NOT EXECUTED
9188: ebfff187 bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
918c: e2509000 subs r9, r0, #0 <== NOT EXECUTED
9190: e59d3000 ldr r3, [sp] <== NOT EXECUTED
9194: 13e07003 mvnne r7, #3 <== NOT EXECUTED
9198: 1afffff3 bne 916c <pipe_write+0x1c> <== NOT EXECUTED
return -EINTR;
if (pipe->Readers == 0) {
919c: e5957010 ldr r7, [r5, #16] <== NOT EXECUTED
91a0: e3570000 cmp r7, #0 <== NOT EXECUTED
91a4: 0a00004f beq 92e8 <pipe_write+0x198> <== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
91a8: e5958004 ldr r8, [r5, #4] <== NOT EXECUTED
91ac: e1540008 cmp r4, r8 <== NOT EXECUTED
91b0: 91a0a004 movls sl, r4 <== NOT EXECUTED
91b4: 83a0a001 movhi sl, #1 <== NOT EXECUTED
}
pipe->waitingWriters --;
if (ret != 0)
goto out_locked;
if (pipe->Readers == 0) {
91b8: e1a07009 mov r7, r9 <== NOT EXECUTED
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
91bc: e28db004 add fp, sp, #4 <== NOT EXECUTED
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
91c0: e595100c ldr r1, [r5, #12] <== NOT EXECUTED
91c4: e0612008 rsb r2, r1, r8 <== NOT EXECUTED
91c8: e152000a cmp r2, sl <== NOT EXECUTED
91cc: 2a000021 bcs 9258 <pipe_write+0x108> <== NOT EXECUTED
if (LIBIO_NODELAY(iop)) {
91d0: e5938014 ldr r8, [r3, #20] <== NOT EXECUTED
91d4: e2188001 ands r8, r8, #1 <== NOT EXECUTED
91d8: 1a00004a bne 9308 <pipe_write+0x1b8> <== NOT EXECUTED
ret = -EAGAIN;
goto out_locked;
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
91dc: e595201c ldr r2, [r5, #28] <== NOT EXECUTED
91e0: e2822001 add r2, r2, #1 <== NOT EXECUTED
91e4: e585201c str r2, [r5, #28] <== NOT EXECUTED
PIPE_UNLOCK(pipe);
91e8: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
91ec: e58d3000 str r3, [sp] <== NOT EXECUTED
91f0: ebfff1b5 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
if (! PIPE_WRITEWAIT(pipe))
91f4: e1a01008 mov r1, r8 <== NOT EXECUTED
91f8: e5950030 ldr r0, [r5, #48] ; 0x30 <== NOT EXECUTED
91fc: eb00089b bl b470 <rtems_barrier_wait> <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
9200: e1a01008 mov r1, r8 <== NOT EXECUTED
9204: e1a02001 mov r2, r1 <== NOT EXECUTED
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
9208: e2508000 subs r8, r0, #0 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
920c: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
}
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
9210: 13e08003 mvnne r8, #3 <== NOT EXECUTED
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
9214: ebfff164 bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
9218: e3500000 cmp r0, #0 <== NOT EXECUTED
921c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
9220: 1a000036 bne 9300 <pipe_write+0x1b0> <== NOT EXECUTED
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
9224: e595201c ldr r2, [r5, #28] <== NOT EXECUTED
if (ret != 0)
9228: e3580000 cmp r8, #0 <== NOT EXECUTED
if (! PIPE_LOCK(pipe)) {
/* WARN waitingWriters not restored! */
ret = -EINTR;
goto out_nolock;
}
pipe->waitingWriters --;
922c: e2422001 sub r2, r2, #1 <== NOT EXECUTED
9230: e585201c str r2, [r5, #28] <== NOT EXECUTED
if (ret != 0)
9234: 1a00002c bne 92ec <pipe_write+0x19c> <== NOT EXECUTED
goto out_locked;
if (pipe->Readers == 0) {
9238: e5952010 ldr r2, [r5, #16] <== NOT EXECUTED
923c: e3520000 cmp r2, #0 <== NOT EXECUTED
9240: 0a000028 beq 92e8 <pipe_write+0x198> <== NOT EXECUTED
9244: e5958004 ldr r8, [r5, #4] <== NOT EXECUTED
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
9248: e595100c ldr r1, [r5, #12] <== NOT EXECUTED
924c: e0612008 rsb r2, r1, r8 <== NOT EXECUTED
9250: e152000a cmp r2, sl <== NOT EXECUTED
9254: 3affffdd bcc 91d0 <pipe_write+0x80> <== NOT EXECUTED
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
chunk1 = pipe->Size - PIPE_WSTART(pipe);
9258: e5950008 ldr r0, [r5, #8] <== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
925c: e069a004 rsb sl, r9, r4 <== NOT EXECUTED
chunk1 = pipe->Size - PIPE_WSTART(pipe);
9260: e0810000 add r0, r1, r0 <== NOT EXECUTED
9264: e1a01008 mov r1, r8 <== NOT EXECUTED
ret = -EPIPE;
goto out_locked;
}
}
chunk = MIN(count - written, PIPE_SPACE(pipe));
9268: e152000a cmp r2, sl <== NOT EXECUTED
926c: 31a0a002 movcc sl, r2 <== NOT EXECUTED
chunk1 = pipe->Size - PIPE_WSTART(pipe);
9270: e58d3000 str r3, [sp] <== NOT EXECUTED
9274: eb0039df bl 179f8 <__umodsi3> <== NOT EXECUTED
9278: e0608008 rsb r8, r0, r8 <== NOT EXECUTED
if (chunk > chunk1) {
927c: e15a0008 cmp sl, r8 <== NOT EXECUTED
9280: e59d3000 ldr r3, [sp] <== NOT EXECUTED
9284: da000021 ble 9310 <pipe_write+0x1c0> <== NOT EXECUTED
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
9288: e5952000 ldr r2, [r5] <== NOT EXECUTED
928c: e0861009 add r1, r6, r9 <== NOT EXECUTED
9290: e0820000 add r0, r2, r0 <== NOT EXECUTED
9294: e1a02008 mov r2, r8 <== NOT EXECUTED
9298: eb001616 bl eaf8 <memcpy> <== NOT EXECUTED
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
929c: e0881009 add r1, r8, r9 <== NOT EXECUTED
92a0: e0861001 add r1, r6, r1 <== NOT EXECUTED
92a4: e068200a rsb r2, r8, sl <== NOT EXECUTED
92a8: e5950000 ldr r0, [r5] <== NOT EXECUTED
92ac: eb001611 bl eaf8 <memcpy> <== NOT EXECUTED
92b0: e59d3000 ldr r3, [sp] <== NOT EXECUTED
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
92b4: e595200c ldr r2, [r5, #12] <== NOT EXECUTED
if (pipe->waitingReaders > 0)
92b8: e5951018 ldr r1, [r5, #24] <== NOT EXECUTED
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
92bc: e082200a add r2, r2, sl <== NOT EXECUTED
if (pipe->waitingReaders > 0)
92c0: e3510000 cmp r1, #0 <== NOT EXECUTED
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
pipe->Length += chunk;
92c4: e585200c str r2, [r5, #12] <== NOT EXECUTED
if (pipe->waitingReaders > 0)
92c8: 1a000018 bne 9330 <pipe_write+0x1e0> <== NOT EXECUTED
PIPE_WAKEUPREADERS(pipe);
written += chunk;
92cc: e087700a add r7, r7, sl <== NOT EXECUTED
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
92d0: e1540007 cmp r4, r7 <== NOT EXECUTED
92d4: e1a09007 mov r9, r7 <== NOT EXECUTED
92d8: 9a00001a bls 9348 <pipe_write+0x1f8> <== NOT EXECUTED
92dc: e5958004 ldr r8, [r5, #4] <== NOT EXECUTED
92e0: e3a0a001 mov sl, #1 <== NOT EXECUTED
92e4: eaffffb5 b 91c0 <pipe_write+0x70> <== NOT EXECUTED
92e8: e3e0801f mvn r8, #31 <== NOT EXECUTED
/* Write of more than PIPE_BUF bytes can be interleaved */
chunk = 1;
}
out_locked:
PIPE_UNLOCK(pipe);
92ec: e5950028 ldr r0, [r5, #40] ; 0x28 <== NOT EXECUTED
92f0: ebfff175 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
/* Signal SIGPIPE */
if (ret == -EPIPE)
kill(getpid(), SIGPIPE);
#endif
if (written > 0)
92f4: e3570000 cmp r7, #0 <== NOT EXECUTED
92f8: d1a07008 movle r7, r8 <== NOT EXECUTED
92fc: eaffff9a b 916c <pipe_write+0x1c> <== NOT EXECUTED
/* Wait until there is chunk bytes space or no reader exists */
pipe->waitingWriters ++;
PIPE_UNLOCK(pipe);
if (! PIPE_WRITEWAIT(pipe))
ret = -EINTR;
if (! PIPE_LOCK(pipe)) {
9300: e3e08003 mvn r8, #3 <== NOT EXECUTED
9304: eafffffa b 92f4 <pipe_write+0x1a4> <== NOT EXECUTED
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
while (PIPE_SPACE(pipe) < chunk) {
if (LIBIO_NODELAY(iop)) {
9308: e3e0800a mvn r8, #10 <== NOT EXECUTED
930c: eafffff6 b 92ec <pipe_write+0x19c> <== NOT EXECUTED
if (chunk > chunk1) {
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk1);
memcpy(pipe->Buffer, buffer + written + chunk1, chunk - chunk1);
}
else
memcpy(pipe->Buffer + PIPE_WSTART(pipe), buffer + written, chunk);
9310: e5952000 ldr r2, [r5] <== NOT EXECUTED
9314: e0861009 add r1, r6, r9 <== NOT EXECUTED
9318: e0820000 add r0, r2, r0 <== NOT EXECUTED
931c: e1a0200a mov r2, sl <== NOT EXECUTED
9320: e58d3000 str r3, [sp] <== NOT EXECUTED
9324: eb0015f3 bl eaf8 <memcpy> <== NOT EXECUTED
9328: e59d3000 ldr r3, [sp] <== NOT EXECUTED
932c: eaffffe0 b 92b4 <pipe_write+0x164> <== NOT EXECUTED
pipe->Length += chunk;
if (pipe->waitingReaders > 0)
PIPE_WAKEUPREADERS(pipe);
9330: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED
9334: e1a0100b mov r1, fp <== NOT EXECUTED
9338: e58d3000 str r3, [sp] <== NOT EXECUTED
933c: eb000832 bl b40c <rtems_barrier_release> <== NOT EXECUTED
9340: e59d3000 ldr r3, [sp] <== NOT EXECUTED
9344: eaffffe0 b 92cc <pipe_write+0x17c> <== NOT EXECUTED
}
/* Write of PIPE_BUF bytes or less shall not be interleaved */
chunk = count <= pipe->Size ? count : 1;
while (written < count) {
9348: e3a08000 mov r8, #0 <== NOT EXECUTED
934c: eaffffe6 b 92ec <pipe_write+0x19c> <== NOT EXECUTED
0000a520 <ramdisk_allocate>:
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
a520: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
a524: e1a04000 mov r4, r0
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
a528: e3a00010 mov r0, #16
void *area_begin,
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
a52c: e1a05001 mov r5, r1
a530: e1a08002 mov r8, r2
a534: e203a0ff and sl, r3, #255 ; 0xff
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
a538: ebffe3c9 bl 3464 <malloc>
if (rd == NULL) {
a53c: e3500000 cmp r0, #0
uint32_t block_size,
rtems_blkdev_bnum block_count,
bool trace
)
{
struct ramdisk *rd = malloc(sizeof(struct ramdisk));
a540: e1a07000 mov r7, r0
a544: e1a06000 mov r6, r0
if (rd == NULL) {
a548: 0a000008 beq a570 <ramdisk_allocate+0x50>
return NULL;
}
if (area_begin == NULL) {
a54c: e3540000 cmp r4, #0
return NULL;
}
rd->malloced = true;
} else {
rd->malloced = false;
a550: 13a03000 movne r3, #0
a554: 15c0300d strbne r3, [r0, #13]
if (rd == NULL) {
return NULL;
}
if (area_begin == NULL) {
a558: 0a000006 beq a578 <ramdisk_allocate+0x58>
}
rd->block_size = block_size;
rd->block_num = block_count;
rd->area = area_begin;
rd->trace = trace;
rd->initialized = true;
a55c: e3a03001 mov r3, #1
a560: e5c6300c strb r3, [r6, #12]
}
rd->malloced = true;
} else {
rd->malloced = false;
}
rd->block_size = block_size;
a564: e8860120 stm r6, {r5, r8}
rd->block_num = block_count; rd->area = area_begin;
a568: e5864008 str r4, [r6, #8]
rd->trace = trace;
a56c: e5c6a00e strb sl, [r6, #14]
rd->initialized = true;
return rd;
}
a570: e1a00007 mov r0, r7
a574: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
if (rd == NULL) {
return NULL;
}
if (area_begin == NULL) {
area_begin = calloc(block_count, block_size);
a578: e1a00008 mov r0, r8
a57c: e1a01005 mov r1, r5
a580: ebffe248 bl 2ea8 <calloc>
if (area_begin == NULL) {
a584: e2504000 subs r4, r0, #0
free(rd);
return NULL;
}
rd->malloced = true;
a588: 13a03001 movne r3, #1
a58c: 15c7300d strbne r3, [r7, #13]
return NULL;
}
if (area_begin == NULL) {
area_begin = calloc(block_count, block_size);
if (area_begin == NULL) {
a590: 1afffff1 bne a55c <ramdisk_allocate+0x3c>
free(rd);
a594: e1a00007 mov r0, r7 <== NOT EXECUTED
a598: ebffe2d8 bl 3100 <free> <== NOT EXECUTED
a59c: e1a07004 mov r7, r4 <== NOT EXECUTED
return NULL;
a5a0: eafffff2 b a570 <ramdisk_allocate+0x50> <== NOT EXECUTED
00020ebc <ramdisk_initialize>:
rtems_device_driver
ramdisk_initialize(
rtems_device_major_number major,
rtems_device_minor_number minor __attribute__((unused)),
void *arg __attribute__((unused)))
{
20ebc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
20ec0: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED
20ec4: e1a09000 mov r9, r0 <== NOT EXECUTED
rtems_device_minor_number i;
rtems_ramdisk_config *c = rtems_ramdisk_configuration;
struct ramdisk *r;
rtems_status_code rc;
rc = rtems_disk_io_initialize();
20ec8: ebff95c4 bl 65e0 <rtems_disk_io_initialize> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
20ecc: e3500000 cmp r0, #0 <== NOT EXECUTED 20ed0: e58d0010 str r0, [sp, #16] <== NOT EXECUTED 20ed4: 0a000002 beq 20ee4 <ramdisk_initialize+0x28> <== NOT EXECUTED
}
r->initialized = false;
}
}
return RTEMS_SUCCESSFUL;
}
20ed8: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED
20edc: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
20ee0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* This is allocating memory for a RAM disk which will persist for
* the life of the system. RTEMS has no "de-initialize" driver call
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
20ee4: e59f7114 ldr r7, [pc, #276] ; 21000 <ramdisk_initialize+0x144><== NOT EXECUTED 20ee8: e3a01010 mov r1, #16 <== NOT EXECUTED 20eec: e5970000 ldr r0, [r7] <== NOT EXECUTED 20ef0: ebff9a1a bl 7760 <calloc> <== NOT EXECUTED
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
20ef4: e5973000 ldr r3, [r7] <== NOT EXECUTED
* the life of the system. RTEMS has no "de-initialize" driver call
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
20ef8: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
20efc: e3530000 cmp r3, #0 <== NOT EXECUTED
* This is allocating memory for a RAM disk which will persist for
* the life of the system. RTEMS has no "de-initialize" driver call
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
20f00: e1a04000 mov r4, r0 <== NOT EXECUTED
r->trace = false;
20f04: e5c0100e strb r1, [r0, #14] <== NOT EXECUTED
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
20f08: 0afffff2 beq 20ed8 <ramdisk_initialize+0x1c> <== NOT EXECUTED 20f0c: e59f60f0 ldr r6, [pc, #240] ; 21004 <ramdisk_initialize+0x148><== NOT EXECUTED 20f10: e1a05001 mov r5, r1 <== NOT EXECUTED 20f14: e28d8014 add r8, sp, #20 <== NOT EXECUTED
{
if (r->malloced)
{
free(r->area);
}
r->initialized = false;
20f18: e1a0a001 mov sl, r1 <== NOT EXECUTED
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
20f1c: e59f30e4 ldr r3, [pc, #228] ; 21008 <ramdisk_initialize+0x14c><== NOT EXECUTED
20f20: e8930007 ldm r3, {r0, r1, r2} <== NOT EXECUTED
20f24: e1a0c008 mov ip, r8 <== NOT EXECUTED
20f28: e8ac0003 stmia ip!, {r0, r1} <== NOT EXECUTED
20f2c: e5cc2000 strb r2, [ip] <== NOT EXECUTED
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
20f30: e5dd001c ldrb r0, [sp, #28] <== NOT EXECUTED
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
20f34: e5961008 ldr r1, [r6, #8] <== NOT EXECUTED
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
r->block_size = c->block_size;
20f38: e896000c ldm r6, {r2, r3} <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
20f3c: e58d9020 str r9, [sp, #32] <== NOT EXECUTED
temp.__overlay.minor = _minor;
20f40: e58d5024 str r5, [sp, #36] ; 0x24 <== NOT EXECUTED
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
20f44: e0800005 add r0, r0, r5 <== NOT EXECUTED
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
20f48: e3510000 cmp r1, #0 <== NOT EXECUTED
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
{
dev_t dev = rtems_filesystem_make_dev_t(major, i);
char name [] = RAMDISK_DEVICE_BASE_NAME "a";
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
20f4c: e5cd001c strb r0, [sp, #28] <== NOT EXECUTED
r->block_size = c->block_size;
20f50: e884000c stm r4, {r2, r3} <== NOT EXECUTED
return temp.device;
20f54: e28dc020 add ip, sp, #32 <== NOT EXECUTED
20f58: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
r->block_num = c->block_num;
if (c->location == NULL)
20f5c: 0a000019 beq 20fc8 <ramdisk_initialize+0x10c> <== NOT EXECUTED
}
else
{
r->malloced = false;
r->initialized = true;
r->area = c->location;
20f60: e5841008 str r1, [r4, #8] <== NOT EXECUTED
}
}
else
{
r->malloced = false;
r->initialized = true;
20f64: e3a01001 mov r1, #1 <== NOT EXECUTED
r->initialized = true;
}
}
else
{
r->malloced = false;
20f68: e5c4a00d strb sl, [r4, #13] <== NOT EXECUTED
r->initialized = true;
20f6c: e5c4100c strb r1, [r4, #12] <== NOT EXECUTED
r->area = c->location;
}
rc = rtems_disk_create_phys(dev, c->block_size, c->block_num,
20f70: e1a0100c mov r1, ip <== NOT EXECUTED
20f74: e59fc090 ldr ip, [pc, #144] ; 2100c <ramdisk_initialize+0x150><== NOT EXECUTED
20f78: e1a0000b mov r0, fp <== NOT EXECUTED
20f7c: e58dc000 str ip, [sp] <== NOT EXECUTED
20f80: e98d0110 stmib sp, {r4, r8} <== NOT EXECUTED
20f84: ebff9767 bl 6d28 <rtems_disk_create_phys> <== NOT EXECUTED
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
20f88: e3500000 cmp r0, #0 <== NOT EXECUTED 20f8c: 0a000003 beq 20fa0 <ramdisk_initialize+0xe4> <== NOT EXECUTED
{
if (r->malloced)
20f90: e5d4300d ldrb r3, [r4, #13] <== NOT EXECUTED 20f94: e3530000 cmp r3, #0 <== NOT EXECUTED 20f98: 1a000007 bne 20fbc <ramdisk_initialize+0x100> <== NOT EXECUTED
{
free(r->area);
}
r->initialized = false;
20f9c: e5c4a00c strb sl, [r4, #12] <== NOT EXECUTED
* so there is no corresponding free(r). Coverity is correct that
* it is never freed but this is not a problem.
*/
r = calloc(rtems_ramdisk_configuration_size, sizeof(struct ramdisk));
r->trace = false;
for (i = 0; i < rtems_ramdisk_configuration_size; i++, c++, r++)
20fa0: e5973000 ldr r3, [r7] <== NOT EXECUTED 20fa4: e2855001 add r5, r5, #1 <== NOT EXECUTED 20fa8: e1530005 cmp r3, r5 <== NOT EXECUTED 20fac: 9affffc9 bls 20ed8 <ramdisk_initialize+0x1c> <== NOT EXECUTED 20fb0: e286600c add r6, r6, #12 <== NOT EXECUTED 20fb4: e2844010 add r4, r4, #16 <== NOT EXECUTED 20fb8: eaffffd7 b 20f1c <ramdisk_initialize+0x60> <== NOT EXECUTED
ramdisk_ioctl, r, name);
if (rc != RTEMS_SUCCESSFUL)
{
if (r->malloced)
{
free(r->area);
20fbc: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED 20fc0: ebff9b6a bl 7d70 <free> <== NOT EXECUTED 20fc4: eafffff4 b 20f9c <ramdisk_initialize+0xe0> <== NOT EXECUTED
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
{
r->malloced = true;
20fc8: e3a01001 mov r1, #1 <== NOT EXECUTED
r->area = malloc(r->block_size * r->block_num);
20fcc: e0000392 mul r0, r2, r3 <== NOT EXECUTED 20fd0: e58dc00c str ip, [sp, #12] <== NOT EXECUTED
name [sizeof(RAMDISK_DEVICE_BASE_NAME)] += i;
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
{
r->malloced = true;
20fd4: e5c4100d strb r1, [r4, #13] <== NOT EXECUTED
r->area = malloc(r->block_size * r->block_num);
20fd8: ebff9d28 bl 8480 <malloc> <== NOT EXECUTED
if (r->area == NULL) /* No enough memory for this disk */
20fdc: e3500000 cmp r0, #0 <== NOT EXECUTED
r->block_size = c->block_size;
r->block_num = c->block_num;
if (c->location == NULL)
{
r->malloced = true;
r->area = malloc(r->block_size * r->block_num);
20fe0: e5840008 str r0, [r4, #8] <== NOT EXECUTED
if (r->area == NULL) /* No enough memory for this disk */
20fe4: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED
{
r->initialized = false;
20fe8: 05c4000c strbeq r0, [r4, #12] <== NOT EXECUTED
r->block_num = c->block_num;
if (c->location == NULL)
{
r->malloced = true;
r->area = malloc(r->block_size * r->block_num);
if (r->area == NULL) /* No enough memory for this disk */
20fec: 0affffeb beq 20fa0 <ramdisk_initialize+0xe4> <== NOT EXECUTED
r->initialized = false;
continue;
}
else
{
r->initialized = true;
20ff0: e3a03001 mov r3, #1 <== NOT EXECUTED
20ff4: e5c4300c strb r3, [r4, #12] <== NOT EXECUTED
20ff8: e896000c ldm r6, {r2, r3} <== NOT EXECUTED
20ffc: eaffffdb b 20f70 <ramdisk_initialize+0xb4> <== NOT EXECUTED
0000a3f8 <ramdisk_ioctl>:
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
switch (req)
a3f8: e3a03961 mov r3, #1589248 ; 0x184000
a3fc: e2833c02 add r3, r3, #512 ; 0x200
a400: e2833107 add r3, r3, #-1073741823 ; 0xc0000001
a404: e1510003 cmp r1, r3
return 0;
}
int
ramdisk_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
a408: e92d41f0 push {r4, r5, r6, r7, r8, lr}
a40c: e1a05002 mov r5, r2
switch (req)
a410: 0a000001 beq a41c <ramdisk_ioctl+0x24>
break;
}
errno = EINVAL;
return -1;
}
a414: e8bd41f0 pop {r4, r5, r6, r7, r8, lr}
}
break;
}
default:
return rtems_blkdev_ioctl (dd, req, argp);
a418: ea0009d5 b cb74 <rtems_blkdev_ioctl>
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (r->req)
a41c: e5926000 ldr r6, [r2]
a420: e3560000 cmp r6, #0
switch (req)
{
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
a424: e590702c ldr r7, [r0, #44] ; 0x2c
switch (r->req)
a428: 1a000017 bne a48c <ramdisk_ioctl+0x94>
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
a42c: e5923010 ldr r3, [r2, #16] <== NOT EXECUTED
a430: e3530000 cmp r3, #0 <== NOT EXECUTED
#endif
static int
ramdisk_read(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *from = rd->area;
a434: e5978008 ldr r8, [r7, #8] <== NOT EXECUTED
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
a438: 0a00000b beq a46c <ramdisk_ioctl+0x74> <== NOT EXECUTED
a43c: e2824018 add r4, r2, #24 <== NOT EXECUTED
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
from + (sg->block * rd->block_size));
#endif
memcpy(sg->buffer, from + (sg->block * rd->block_size), sg->length);
a440: e5941000 ldr r1, [r4] <== NOT EXECUTED
a444: e5973000 ldr r3, [r7] <== NOT EXECUTED
a448: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
a44c: e0218193 mla r1, r3, r1, r8 <== NOT EXECUTED
a450: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED
a454: eb002172 bl 12a24 <memcpy> <== NOT EXECUTED
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk read: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
a458: e5953010 ldr r3, [r5, #16] <== NOT EXECUTED
a45c: e2866001 add r6, r6, #1 <== NOT EXECUTED
a460: e1560003 cmp r6, r3 <== NOT EXECUTED
a464: e2844010 add r4, r4, #16 <== NOT EXECUTED
a468: 3afffff4 bcc a440 <ramdisk_ioctl+0x48> <== NOT EXECUTED
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
}
req->status = RTEMS_SUCCESSFUL;
a46c: e3a04000 mov r4, #0
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
a470: e5950008 ldr r0, [r5, #8]
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
}
req->status = RTEMS_SUCCESSFUL;
a474: e585400c str r4, [r5, #12]
req->req_done(req->done_arg, RTEMS_SUCCESSFUL);
a478: e1a01004 mov r1, r4
a47c: e1a0e00f mov lr, pc
a480: e595f004 ldr pc, [r5, #4]
a484: e1a00004 mov r0, r4
{
case RTEMS_BLKDEV_REQ_READ:
return ramdisk_read(rd, r);
case RTEMS_BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
a488: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
case RTEMS_BLKIO_REQUEST:
{
rtems_blkdev_request *r = argp;
struct ramdisk *rd = rtems_disk_get_driver_data(dd);
switch (r->req)
a48c: e3560001 cmp r6, #1
a490: 0a000004 beq a4a8 <ramdisk_ioctl+0xb0>
case RTEMS_BLKDEV_REQ_WRITE:
return ramdisk_write(rd, r);
default:
errno = EINVAL;
a494: eb001f54 bl 121ec <__errno> <== NOT EXECUTED
a498: e3a03016 mov r3, #22 <== NOT EXECUTED
a49c: e5803000 str r3, [r0] <== NOT EXECUTED
a4a0: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
a4a4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
a4a8: e5923010 ldr r3, [r2, #16]
a4ac: e3530000 cmp r3, #0
}
static int
ramdisk_write(struct ramdisk *rd, rtems_blkdev_request *req)
{
uint8_t *to = rd->area;
a4b0: e5978008 ldr r8, [r7, #8]
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
a4b4: 0affffec beq a46c <ramdisk_ioctl+0x74>
a4b8: e2824018 add r4, r2, #24
a4bc: e3a06000 mov r6, #0
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: buf=%d block=%d length=%d off=%d addr=%p",
i, sg->block, sg->length, sg->block * rd->block_size,
to + (sg->block * rd->block_size));
#endif
memcpy(to + (sg->block * rd->block_size), sg->buffer, sg->length);
a4c0: e5940000 ldr r0, [r4]
a4c4: e5973000 ldr r3, [r7]
a4c8: e5941008 ldr r1, [r4, #8]
a4cc: e0208093 mla r0, r3, r0, r8
a4d0: e5942004 ldr r2, [r4, #4]
a4d4: eb002152 bl 12a24 <memcpy>
#if RTEMS_RAMDISK_TRACE
rtems_ramdisk_printf (rd, "ramdisk write: start=%d, blocks=%d",
req->bufs[0].block, req->bufnum);
#endif
for (i = 0, sg = req->bufs; i < req->bufnum; i++, sg++)
a4d8: e5953010 ldr r3, [r5, #16]
a4dc: e2866001 add r6, r6, #1
a4e0: e1560003 cmp r6, r3
a4e4: e2844010 add r4, r4, #16
a4e8: 3afffff4 bcc a4c0 <ramdisk_ioctl+0xc8>
a4ec: eaffffde b a46c <ramdisk_ioctl+0x74>
0000a5a4 <ramdisk_register>:
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
a5a4: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
a5a8: e24dd010 sub sp, sp, #16
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_device_major_number major = 0;
a5ac: e3a0e000 mov lr, #0
a5b0: e28dc010 add ip, sp, #16
a5b4: e52ce004 str lr, [ip, #-4]!
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
a5b8: e1a07002 mov r7, r2
a5bc: e1a05000 mov r5, r0
a5c0: e1a04001 mov r4, r1
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
a5c4: e1a0000e mov r0, lr
a5c8: e1a0200c mov r2, ip
a5cc: e59f1094 ldr r1, [pc, #148] ; a668 <ramdisk_register+0xc4>
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
a5d0: e1a06003 mov r6, r3
a5d4: e59d9030 ldr r9, [sp, #48] ; 0x30
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
a5d8: ebfff304 bl 71f0 <rtems_io_register_driver>
rtems_blkdev_bnum block_count,
bool trace,
const char *disk,
dev_t *dev_ptr
)
{
a5dc: e20780ff and r8, r7, #255 ; 0xff
rtems_device_major_number major = 0;
ramdisk *rd = NULL;
dev_t dev = 0;
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
if (sc != RTEMS_SUCCESSFUL) {
a5e0: e2507000 subs r7, r0, #0
a5e4: 0a000002 beq a5f4 <ramdisk_register+0x50>
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, block_size, block_count, trace);
if (rd == NULL) {
rtems_io_unregister_driver(major);
a5e8: e3a0000d mov r0, #13 <== NOT EXECUTED
}
*dev_ptr = dev;
return RTEMS_SUCCESSFUL;
}
a5ec: e28dd010 add sp, sp, #16
a5f0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
sc = rtems_io_register_driver(0, &ramdisk_ops, &major);
if (sc != RTEMS_SUCCESSFUL) {
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, block_size, block_count, trace);
a5f4: e1a03008 mov r3, r8
a5f8: e1a01005 mov r1, r5
a5fc: e1a02004 mov r2, r4
a600: ebffffc6 bl a520 <ramdisk_allocate>
if (rd == NULL) {
a604: e2508000 subs r8, r0, #0
a608: 0a000013 beq a65c <ramdisk_register+0xb8>
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
a60c: e59da00c ldr sl, [sp, #12]
return RTEMS_UNSATISFIED;
}
dev = rtems_filesystem_make_dev_t(major, 0);
sc = rtems_disk_create_phys(
a610: e59fc054 ldr ip, [pc, #84] ; a66c <ramdisk_register+0xc8>
a614: e1a01007 mov r1, r7
a618: e1a02005 mov r2, r5
a61c: e1a03004 mov r3, r4
a620: e1a0000a mov r0, sl
a624: e58dc000 str ip, [sp]
a628: e58d6008 str r6, [sp, #8]
a62c: e58d8004 str r8, [sp, #4]
a630: ebffdfe9 bl 25dc <rtems_disk_create_phys>
block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
a634: e3500000 cmp r0, #0
rtems_io_unregister_driver(major);
return RTEMS_UNSATISFIED;
}
*dev_ptr = dev;
a638: 0589a000 streq sl, [r9]
a63c: 05890004 streq r0, [r9, #4]
block_count,
ramdisk_ioctl,
rd,
disk
);
if (sc != RTEMS_SUCCESSFUL) {
a640: 0affffe9 beq a5ec <ramdisk_register+0x48>
ramdisk_free(rd);
a644: e1a00008 mov r0, r8 <== NOT EXECUTED
a648: ebffffa8 bl a4f0 <ramdisk_free> <== NOT EXECUTED
rtems_io_unregister_driver(major);
a64c: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED
a650: ebfff33e bl 7350 <rtems_io_unregister_driver> <== NOT EXECUTED
a654: e3a0000d mov r0, #13 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
a658: eaffffe3 b a5ec <ramdisk_register+0x48> <== NOT EXECUTED
return RTEMS_UNSATISFIED;
}
rd = ramdisk_allocate(NULL, block_size, block_count, trace);
if (rd == NULL) {
rtems_io_unregister_driver(major);
a65c: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED
a660: ebfff33a bl 7350 <rtems_io_unregister_driver> <== NOT EXECUTED
a664: eaffffdf b a5e8 <ramdisk_register+0x44> <== NOT EXECUTED
00019d94 <read>:
)
{
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
19d94: e59f30bc ldr r3, [pc, #188] ; 19e58 <read+0xc4> 19d98: e5933000 ldr r3, [r3] 19d9c: e1500003 cmp r0, r3
ssize_t read(
int fd,
void *buffer,
size_t count
)
{
19da0: e92d4810 push {r4, fp, lr}
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
19da4: 2a00001c bcs 19e1c <read+0x88>
iop = rtems_libio_iop( fd );
19da8: e59f40ac ldr r4, [pc, #172] ; 19e5c <read+0xc8> 19dac: e5944000 ldr r4, [r4] 19db0: e0844300 add r4, r4, r0, lsl #6
rtems_libio_check_is_open( iop );
19db4: e5940014 ldr r0, [r4, #20] 19db8: e3100c01 tst r0, #256 ; 0x100
19dbc: 0a000016 beq 19e1c <read+0x88> rtems_libio_check_buffer( buffer );
19dc0: e3510000 cmp r1, #0
19dc4: 0a00001e beq 19e44 <read+0xb0> rtems_libio_check_count( count );
19dc8: e3520000 cmp r2, #0
19dcc: 01a00002 moveq r0, r2
19dd0: 08bd8810 popeq {r4, fp, pc}
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
19dd4: e3100002 tst r0, #2
19dd8: 0a00000f beq 19e1c <read+0x88>
/*
* Now process the read().
*/
if ( !iop->handlers->read_h )
19ddc: e594303c ldr r3, [r4, #60] ; 0x3c 19de0: e5933008 ldr r3, [r3, #8] 19de4: e3530000 cmp r3, #0
19de8: 0a000010 beq 19e30 <read+0x9c>
rtems_set_errno_and_return_minus_one( ENOTSUP );
rc = (*iop->handlers->read_h)( iop, buffer, count );
19dec: e1a00004 mov r0, r4 19df0: e1a0e00f mov lr, pc 19df4: e12fff13 bx r3
if ( rc > 0 )
19df8: e3500000 cmp r0, #0
19dfc: d8bd8810 pople {r4, fp, pc}
iop->offset += rc;
19e00: e284c00c add ip, r4, #12
19e04: e89c1800 ldm ip, {fp, ip}
19e08: e09b2000 adds r2, fp, r0
19e0c: e0ac3fc0 adc r3, ip, r0, asr #31
19e10: e584200c str r2, [r4, #12]
19e14: e5843010 str r3, [r4, #16]
return rc;
}
19e18: e8bd8810 pop {r4, fp, pc}
rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
19e1c: ebffd127 bl e2c0 <__errno>
19e20: e3a03009 mov r3, #9
19e24: e5803000 str r3, [r0]
19e28: e3e00000 mvn r0, #0
19e2c: e8bd8810 pop {r4, fp, pc}
/*
* Now process the read().
*/
if ( !iop->handlers->read_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
19e30: ebffd122 bl e2c0 <__errno> <== NOT EXECUTED
19e34: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
19e38: e5803000 str r3, [r0] <== NOT EXECUTED
19e3c: e3e00000 mvn r0, #0 <== NOT EXECUTED
19e40: e8bd8810 pop {r4, fp, pc} <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
19e44: ebffd11d bl e2c0 <__errno> <== NOT EXECUTED
19e48: e3a03016 mov r3, #22 <== NOT EXECUTED
19e4c: e5803000 str r3, [r0] <== NOT EXECUTED
19e50: e3e00000 mvn r0, #0 <== NOT EXECUTED
19e54: e8bd8810 pop {r4, fp, pc} <== NOT EXECUTED
0002a5ec <readlink>:
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
2a5ec: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
2a5f0: e2516000 subs r6, r1, #0
ssize_t readlink(
const char *pathname,
char *buf,
size_t bufsize
)
{
2a5f4: e24dd018 sub sp, sp, #24 2a5f8: e1a05002 mov r5, r2 2a5fc: e1a07000 mov r7, r0
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
2a600: 0a000032 beq 2a6d0 <readlink+0xe4>
rtems_set_errno_and_return_minus_one( EFAULT );
result = rtems_filesystem_evaluate_path( pathname, strlen( pathname ),
2a604: eb007d76 bl 49be4 <strlen> 2a608: e28d4004 add r4, sp, #4 2a60c: e3a0c000 mov ip, #0 2a610: e1a01000 mov r1, r0 2a614: e1a0200c mov r2, ip 2a618: e1a00007 mov r0, r7 2a61c: e1a03004 mov r3, r4 2a620: e58dc000 str ip, [sp] 2a624: ebff75af bl 7ce8 <rtems_filesystem_evaluate_path>
0, &loc, false );
if ( result != 0 )
2a628: e3500000 cmp r0, #0
2a62c: 1a000025 bne 2a6c8 <readlink+0xdc>
return -1;
if ( !loc.ops->node_type_h ){
2a630: e59d2010 ldr r2, [sp, #16] 2a634: e5923010 ldr r3, [r2, #16] 2a638: e3530000 cmp r3, #0
2a63c: 0a000019 beq 2a6a8 <readlink+0xbc>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
2a640: e1a00004 mov r0, r4 2a644: e1a0e00f mov lr, pc 2a648: e12fff13 bx r3 2a64c: e3500004 cmp r0, #4
2a650: 1a000023 bne 2a6e4 <readlink+0xf8>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( EINVAL );
}
if ( !loc.ops->readlink_h ){
2a654: e59d2010 ldr r2, [sp, #16] 2a658: e592303c ldr r3, [r2, #60] ; 0x3c 2a65c: e3530000 cmp r3, #0
2a660: 0a00002c beq 2a718 <readlink+0x12c>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
2a664: e1a02005 mov r2, r5 2a668: e1a01006 mov r1, r6 2a66c: e1a00004 mov r0, r4 2a670: e1a0e00f mov lr, pc 2a674: e12fff13 bx r3
rtems_filesystem_freenode( &loc );
2a678: e59d3010 ldr r3, [sp, #16] 2a67c: e3530000 cmp r3, #0
if ( !loc.ops->readlink_h ){
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.ops->readlink_h)( &loc, buf, bufsize );
2a680: e1a05000 mov r5, r0
rtems_filesystem_freenode( &loc );
2a684: 0a000004 beq 2a69c <readlink+0xb0>
2a688: e593301c ldr r3, [r3, #28] 2a68c: e3530000 cmp r3, #0 2a690: 11a00004 movne r0, r4 2a694: 11a0e00f movne lr, pc 2a698: 112fff13 bxne r3
return result;
}
2a69c: e1a00005 mov r0, r5
2a6a0: e28dd018 add sp, sp, #24
2a6a4: e8bd80f0 pop {r4, r5, r6, r7, pc}
0, &loc, false );
if ( result != 0 )
return -1;
if ( !loc.ops->node_type_h ){
rtems_filesystem_freenode( &loc );
2a6a8: e592301c ldr r3, [r2, #28] <== NOT EXECUTED 2a6ac: e3530000 cmp r3, #0 <== NOT EXECUTED 2a6b0: 11a00004 movne r0, r4 <== NOT EXECUTED 2a6b4: 11a0e00f movne lr, pc <== NOT EXECUTED 2a6b8: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
2a6bc: eb00624b bl 42ff0 <__errno> <== NOT EXECUTED 2a6c0: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 2a6c4: e5803000 str r3, [r0] <== NOT EXECUTED 2a6c8: e3e05000 mvn r5, #0 <== NOT EXECUTED 2a6cc: eafffff2 b 2a69c <readlink+0xb0> <== NOT EXECUTED
{
rtems_filesystem_location_info_t loc;
int result;
if (!buf)
rtems_set_errno_and_return_minus_one( EFAULT );
2a6d0: eb006246 bl 42ff0 <__errno> <== NOT EXECUTED 2a6d4: e3a0300e mov r3, #14 <== NOT EXECUTED 2a6d8: e5803000 str r3, [r0] <== NOT EXECUTED 2a6dc: e3e05000 mvn r5, #0 <== NOT EXECUTED 2a6e0: eaffffed b 2a69c <readlink+0xb0> <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_SYM_LINK ){
rtems_filesystem_freenode( &loc );
2a6e4: e59d3010 ldr r3, [sp, #16] 2a6e8: e3530000 cmp r3, #0
2a6ec: 0a000004 beq 2a704 <readlink+0x118>
2a6f0: e593301c ldr r3, [r3, #28] 2a6f4: e3530000 cmp r3, #0 2a6f8: 11a00004 movne r0, r4 2a6fc: 11a0e00f movne lr, pc 2a700: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( EINVAL );
2a704: eb006239 bl 42ff0 <__errno> 2a708: e3a03016 mov r3, #22 2a70c: e5803000 str r3, [r0] 2a710: e3e05000 mvn r5, #0 2a714: eaffffe0 b 2a69c <readlink+0xb0>
}
if ( !loc.ops->readlink_h ){
rtems_filesystem_freenode( &loc );
2a718: e592301c ldr r3, [r2, #28] <== NOT EXECUTED 2a71c: e3530000 cmp r3, #0 <== NOT EXECUTED 2a720: 11a00004 movne r0, r4 <== NOT EXECUTED 2a724: 11a0e00f movne lr, pc <== NOT EXECUTED 2a728: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
2a72c: eb00622f bl 42ff0 <__errno> <== NOT EXECUTED 2a730: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 2a734: e5803000 str r3, [r0] <== NOT EXECUTED 2a738: e3e05000 mvn r5, #0 <== NOT EXECUTED 2a73c: eaffffd6 b 2a69c <readlink+0xb0> <== NOT EXECUTED
00003cfc <readv>:
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
3cfc: e59f3160 ldr r3, [pc, #352] ; 3e64 <readv+0x168>
3d00: e5933000 ldr r3, [r3]
3d04: e1500003 cmp r0, r3
ssize_t readv(
int fd,
const struct iovec *iov,
int iovcnt
)
{
3d08: e92d49f0 push {r4, r5, r6, r7, r8, fp, lr}
3d0c: e1a04002 mov r4, r2
int v;
int bytes;
rtems_libio_t *iop;
bool all_zeros;
rtems_libio_check_fd( fd );
3d10: 2a000049 bcs 3e3c <readv+0x140>
iop = rtems_libio_iop( fd );
3d14: e59f314c ldr r3, [pc, #332] ; 3e68 <readv+0x16c>
3d18: e5936000 ldr r6, [r3]
3d1c: e0866300 add r6, r6, r0, lsl #6
rtems_libio_check_is_open( iop );
3d20: e5963014 ldr r3, [r6, #20]
3d24: e3130c01 tst r3, #256 ; 0x100
3d28: 0a000043 beq 3e3c <readv+0x140>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
3d2c: e3130002 tst r3, #2
3d30: 0a000041 beq 3e3c <readv+0x140>
/*
* Argument validation on IO vector
*/
if ( !iov )
3d34: e3510000 cmp r1, #0
3d38: 0a000039 beq 3e24 <readv+0x128>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
3d3c: e3520000 cmp r2, #0
3d40: da000037 ble 3e24 <readv+0x128>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
3d44: e3520b01 cmp r2, #1024 ; 0x400
3d48: ca000035 bgt 3e24 <readv+0x128>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !iop->handlers->read_h )
3d4c: e596303c ldr r3, [r6, #60] ; 0x3c
3d50: e5933008 ldr r3, [r3, #8]
3d54: e3530000 cmp r3, #0
3d58: 0a00003c beq 3e50 <readv+0x154>
rtems_set_errno_and_return_minus_one( ENOTSUP );
3d5c: e1a05001 mov r5, r1
3d60: e3a01000 mov r1, #0
3d64: e1a02005 mov r2, r5
3d68: e3a07001 mov r7, #1
3d6c: e1a00001 mov r0, r1
3d70: ea000000 b 3d78 <readv+0x7c>
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3d74: e1a00008 mov r0, r8
ssize_t old;
if ( !iov[v].iov_base )
3d78: e592c000 ldr ip, [r2]
3d7c: e35c0000 cmp ip, #0
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3d80: e2811001 add r1, r1, #1
ssize_t old;
if ( !iov[v].iov_base )
3d84: 0a000026 beq 3e24 <readv+0x128>
if ( iov[v].iov_len < 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
/* check for wrap */
old = total;
total += iov[v].iov_len;
3d88: e592c004 ldr ip, [r2, #4]
3d8c: e080800c add r8, r0, ip
if ( total < old )
3d90: e1580000 cmp r8, r0
3d94: ba000022 blt 3e24 <readv+0x128>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
3d98: e35c0000 cmp ip, #0
3d9c: 13a07000 movne r7, #0
* are obvious errors in the iovec. So this extra loop ensures
* that we do not do anything if there is an argument error.
*/
all_zeros = true;
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3da0: e1540001 cmp r4, r1
3da4: e2822008 add r2, r2, #8
3da8: cafffff1 bgt 3d74 <readv+0x78>
/*
* A readv with all zeros logically has no effect. Even though
* OpenGroup didn't address this case as they did with writev(),
* we will handle it the same way for symmetry.
*/
if ( all_zeros == true ) {
3dac: e3570000 cmp r7, #0
3db0: 13a08000 movne r8, #0
3db4: 1a00001e bne 3e34 <readv+0x138>
3db8: e1a08007 mov r8, r7
3dbc: ea00000f b 3e00 <readv+0x104>
bytes = (*iop->handlers->read_h)( iop, iov[v].iov_base, iov[v].iov_len );
if ( bytes < 0 )
return -1;
if ( bytes > 0 ) {
3dc0: 0a000006 beq 3de0 <readv+0xe4>
iop->offset += bytes;
3dc4: e286c00c add ip, r6, #12
3dc8: e89c1800 ldm ip, {fp, ip}
3dcc: e09b2000 adds r2, fp, r0
3dd0: e0ac3fc0 adc r3, ip, r0, asr #31
3dd4: e586200c str r2, [r6, #12]
3dd8: e5863010 str r3, [r6, #16]
total += bytes;
3ddc: e0888000 add r8, r8, r0
}
if (bytes != iov[ v ].iov_len)
3de0: e5953004 ldr r3, [r5, #4]
3de4: e1500003 cmp r0, r3
3de8: 1a000011 bne 3e34 <readv+0x138>
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3dec: e1540007 cmp r4, r7
3df0: e2855008 add r5, r5, #8
3df4: da00000e ble 3e34 <readv+0x138>
3df8: e596303c ldr r3, [r6, #60] ; 0x3c
3dfc: e5933008 ldr r3, [r3, #8]
bytes = (*iop->handlers->read_h)( iop, iov[v].iov_base, iov[v].iov_len );
3e00: e8950006 ldm r5, {r1, r2}
3e04: e1a00006 mov r0, r6
3e08: e1a0e00f mov lr, pc
3e0c: e12fff13 bx r3
if ( bytes < 0 )
3e10: e3500000 cmp r0, #0
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3e14: e2877001 add r7, r7, #1
bytes = (*iop->handlers->read_h)( iop, iov[v].iov_base, iov[v].iov_len );
if ( bytes < 0 )
3e18: aaffffe8 bge 3dc0 <readv+0xc4>
}
/*
* Now process the readv().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
3e1c: e3e08000 mvn r8, #0 <== NOT EXECUTED
3e20: ea000003 b 3e34 <readv+0x138> <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old )
rtems_set_errno_and_return_minus_one( EINVAL );
3e24: eb002d96 bl f484 <__errno>
3e28: e3a03016 mov r3, #22
3e2c: e5803000 str r3, [r0]
3e30: e3e08000 mvn r8, #0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
3e34: e1a00008 mov r0, r8
3e38: e8bd89f0 pop {r4, r5, r6, r7, r8, fp, pc}
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_READ, EBADF );
3e3c: eb002d90 bl f484 <__errno> <== NOT EXECUTED
3e40: e3a03009 mov r3, #9 <== NOT EXECUTED
3e44: e5803000 str r3, [r0] <== NOT EXECUTED
3e48: e3e08000 mvn r8, #0 <== NOT EXECUTED
3e4c: eafffff8 b 3e34 <readv+0x138> <== NOT EXECUTED
if ( iovcnt > IOV_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !iop->handlers->read_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
3e50: eb002d8b bl f484 <__errno> <== NOT EXECUTED
3e54: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
3e58: e5803000 str r3, [r0] <== NOT EXECUTED
3e5c: e3e08000 mvn r8, #0 <== NOT EXECUTED
3e60: eafffff3 b 3e34 <readv+0x138> <== NOT EXECUTED
00019eb8 <realloc>:
{
uintptr_t old_size;
char *new_area;
uintptr_t resize;
MSBUMP(realloc_calls, 1);
19eb8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
19ebc: e59f3118 ldr r3, [pc, #280] ; 19fdc <realloc+0x124>
{
uintptr_t old_size;
char *new_area;
uintptr_t resize;
MSBUMP(realloc_calls, 1);
19ec0: e59f5118 ldr r5, [pc, #280] ; 19fe0 <realloc+0x128>
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
19ec4: e5932000 ldr r2, [r3]
{
uintptr_t old_size;
char *new_area;
uintptr_t resize;
MSBUMP(realloc_calls, 1);
19ec8: e5953010 ldr r3, [r5, #16]
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
19ecc: e3520003 cmp r2, #3
{
uintptr_t old_size;
char *new_area;
uintptr_t resize;
MSBUMP(realloc_calls, 1);
19ed0: e2833001 add r3, r3, #1 19ed4: e24dd004 sub sp, sp, #4 19ed8: e5853010 str r3, [r5, #16] 19edc: e1a04000 mov r4, r0 19ee0: e1a06001 mov r6, r1
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
19ee4: 0a000020 beq 19f6c <realloc+0xb4>
}
/*
* Continue with realloc().
*/
if ( !ptr )
19ee8: e3540000 cmp r4, #0
19eec: 0a00001a beq 19f5c <realloc+0xa4>
return malloc( size );
if ( !size ) {
19ef0: e3560000 cmp r6, #0
19ef4: 0a00000f beq 19f38 <realloc+0x80>
free( ptr );
return (void *) 0;
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
19ef8: e59f70e4 ldr r7, [pc, #228] ; 19fe4 <realloc+0x12c> 19efc: e1a01004 mov r1, r4 19f00: e5970000 ldr r0, [r7] 19f04: e1a0200d mov r2, sp 19f08: eb00006b bl 1a0bc <_Protected_heap_Get_block_size> 19f0c: e2508000 subs r8, r0, #0
19f10: 0a00000c beq 19f48 <realloc+0x90>
#if defined(RTEMS_MALLOC_BOUNDARY_HELPERS)
if (rtems_malloc_boundary_helpers)
resize += (*rtems_malloc_boundary_helpers->overhead)();
#endif
if ( _Protected_heap_Resize_block( RTEMS_Malloc_Heap, ptr, resize ) ) {
19f14: e5970000 ldr r0, [r7] 19f18: e1a01004 mov r1, r4 19f1c: e1a02006 mov r2, r6 19f20: eb000076 bl 1a100 <_Protected_heap_Resize_block> 19f24: e3500000 cmp r0, #0
19f28: 0a00001b beq 19f9c <realloc+0xe4>
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
}
19f2c: e1a00004 mov r0, r4
19f30: e28dd004 add sp, sp, #4
19f34: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
*/
if ( !ptr )
return malloc( size );
if ( !size ) {
free( ptr );
19f38: e1a00004 mov r0, r4 <== NOT EXECUTED 19f3c: ebffa059 bl 20a8 <free> <== NOT EXECUTED 19f40: e1a04006 mov r4, r6 <== NOT EXECUTED
return (void *) 0;
19f44: eafffff8 b 19f2c <realloc+0x74> <== NOT EXECUTED
}
if ( !_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, ptr, &old_size) ) {
errno = EINVAL;
19f48: ebffd0dc bl e2c0 <__errno> 19f4c: e3a03016 mov r3, #22 19f50: e5803000 str r3, [r0] 19f54: e1a04008 mov r4, r8
return (void *) 0;
19f58: eafffff3 b 19f2c <realloc+0x74>
/*
* Continue with realloc().
*/
if ( !ptr )
return malloc( size );
19f5c: e1a00006 mov r0, r6 19f60: ebffa129 bl 240c <malloc> 19f64: e1a04000 mov r4, r0 19f68: eaffffef b 19f2c <realloc+0x74>
/*
* Do not attempt to allocate memory if in a critical section or ISR.
*/
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
19f6c: e59f3074 ldr r3, [pc, #116] ; 19fe8 <realloc+0x130> 19f70: e5933000 ldr r3, [r3] 19f74: e3530000 cmp r3, #0
19f78: 0a000001 beq 19f84 <realloc+0xcc>
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
19f7c: e3a04000 mov r4, #0 19f80: eaffffe9 b 19f2c <realloc+0x74>
if (_System_state_Is_up(_System_state_Get())) {
if (_Thread_Dispatch_disable_level > 0)
return (void *) 0;
if (_ISR_Nest_level > 0)
19f84: e59f3060 ldr r3, [pc, #96] ; 19fec <realloc+0x134> 19f88: e5933000 ldr r3, [r3] 19f8c: e3530000 cmp r3, #0
19f90: 0affffd4 beq 19ee8 <realloc+0x30>
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
free( ptr );
return new_area;
19f94: e3a04000 mov r4, #0 <== NOT EXECUTED 19f98: eaffffe3 b 19f2c <realloc+0x74> <== NOT EXECUTED
* There used to be a free on this error case but it is wrong to
* free the memory per OpenGroup Single UNIX Specification V2
* and the C Standard.
*/
new_area = malloc( size );
19f9c: e1a00006 mov r0, r6 19fa0: ebffa119 bl 240c <malloc>
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
19fa4: e5953004 ldr r3, [r5, #4]
if ( !new_area ) {
19fa8: e2507000 subs r7, r0, #0
* and the C Standard.
*/
new_area = malloc( size );
MSBUMP(malloc_calls, (uint32_t) -1); /* subtract off the malloc */
19fac: e2433001 sub r3, r3, #1 19fb0: e5853004 str r3, [r5, #4]
if ( !new_area ) {
19fb4: 0afffff0 beq 19f7c <realloc+0xc4>
return (void *) 0;
}
memcpy( new_area, ptr, (size < old_size) ? size : old_size );
19fb8: e59d2000 ldr r2, [sp] 19fbc: e1a01004 mov r1, r4 19fc0: e1560002 cmp r6, r2 19fc4: 31a02006 movcc r2, r6 19fc8: ebffd2ca bl eaf8 <memcpy>
free( ptr );
19fcc: e1a00004 mov r0, r4 19fd0: ebffa034 bl 20a8 <free> 19fd4: e1a04007 mov r4, r7
return new_area;
19fd8: eaffffd3 b 19f2c <realloc+0x74>
0002a740 <rmdir>:
#include <rtems/seterr.h>
int rmdir(
const char *pathname
)
{
2a740: e92d40f0 push {r4, r5, r6, r7, lr}
2a744: e24dd030 sub sp, sp, #48 ; 0x30
2a748: e1a07000 mov r7, r0
/*
* Get the parent node of the node we wish to remove. Find the parent path.
*/
parentpathlen = rtems_filesystem_dirname ( pathname );
2a74c: ebff7518 bl 7bb4 <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
2a750: e2505000 subs r5, r0, #0
2a754: 1a00005c bne 2a8cc <rmdir+0x18c>
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
2a758: e28d4018 add r4, sp, #24 2a75c: e1a00007 mov r0, r7 2a760: e28d102c add r1, sp, #44 ; 0x2c 2a764: e1a02004 mov r2, r4 2a768: ebff7bef bl 972c <rtems_filesystem_get_start_loc> 2a76c: e1a06005 mov r6, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
2a770: e1a0e004 mov lr, r4
2a774: e8be000f ldm lr!, {r0, r1, r2, r3}
2a778: e28dc004 add ip, sp, #4
2a77c: e8ac000f stmia ip!, {r0, r1, r2, r3}
2a780: e59e3000 ldr r3, [lr]
name = pathname + parentpathlen;
2a784: e0875005 add r5, r7, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
2a788: e58c3000 str r3, [ip]
name = pathname + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
2a78c: e1a00005 mov r0, r5 2a790: eb007d13 bl 49be4 <strlen> 2a794: e1a01000 mov r1, r0 2a798: e1a00005 mov r0, r5 2a79c: ebff74ef bl 7b60 <rtems_filesystem_prefix_separators> 2a7a0: e0857000 add r7, r5, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
2a7a4: e1a00007 mov r0, r7 2a7a8: eb007d0d bl 49be4 <strlen> 2a7ac: e28d5004 add r5, sp, #4 2a7b0: e3a0c000 mov ip, #0 2a7b4: e1a01000 mov r1, r0 2a7b8: e1a0200c mov r2, ip 2a7bc: e1a00007 mov r0, r7 2a7c0: e1a03005 mov r3, r5 2a7c4: e58dc000 str ip, [sp] 2a7c8: ebff750a bl 7bf8 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
2a7cc: e3500000 cmp r0, #0
2a7d0: 1a00004a bne 2a900 <rmdir+0x1c0>
/*
* Verify you can remove this node as a directory.
*/
if ( !loc.ops->node_type_h ){
2a7d4: e59d2010 ldr r2, [sp, #16] 2a7d8: e5923010 ldr r3, [r2, #16] 2a7dc: e3530000 cmp r3, #0
2a7e0: 0a00006b beq 2a994 <rmdir+0x254>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ){
2a7e4: e1a00005 mov r0, r5 2a7e8: e1a0e00f mov lr, pc 2a7ec: e12fff13 bx r3 2a7f0: e3500001 cmp r0, #1
2a7f4: 1a00001d bne 2a870 <rmdir+0x130>
/*
* Use the filesystems rmnod to remove the node.
*/
if ( !loc.handlers->rmnod_h ){
2a7f8: e59d300c ldr r3, [sp, #12] 2a7fc: e5933034 ldr r3, [r3, #52] ; 0x34 2a800: e3530000 cmp r3, #0
2a804: 0a00004a beq 2a934 <rmdir+0x1f4>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
2a808: e1a00004 mov r0, r4 2a80c: e1a01005 mov r1, r5 2a810: e1a0e00f mov lr, pc 2a814: e12fff13 bx r3
rtems_filesystem_freenode( &loc );
2a818: e59d3010 ldr r3, [sp, #16] 2a81c: e3530000 cmp r3, #0
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
2a820: e1a07000 mov r7, r0
rtems_filesystem_freenode( &loc );
2a824: 0a000004 beq 2a83c <rmdir+0xfc>
2a828: e593301c ldr r3, [r3, #28] 2a82c: e3530000 cmp r3, #0 2a830: 11a00005 movne r0, r5 2a834: 11a0e00f movne lr, pc 2a838: 112fff13 bxne r3
if ( free_parentloc )
2a83c: e3560000 cmp r6, #0
2a840: 0a000007 beq 2a864 <rmdir+0x124>
rtems_filesystem_freenode( &parentloc );
2a844: e59d3024 ldr r3, [sp, #36] ; 0x24 2a848: e3530000 cmp r3, #0
2a84c: 0a000004 beq 2a864 <rmdir+0x124>
2a850: e593301c ldr r3, [r3, #28] 2a854: e3530000 cmp r3, #0 2a858: 11a00004 movne r0, r4 2a85c: 11a0e00f movne lr, pc 2a860: 112fff13 bxne r3
return result;
}
2a864: e1a00007 mov r0, r7
2a868: e28dd030 add sp, sp, #48 ; 0x30
2a86c: e8bd80f0 pop {r4, r5, r6, r7, pc}
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( (*loc.ops->node_type_h)( &loc ) != RTEMS_FILESYSTEM_DIRECTORY ){
rtems_filesystem_freenode( &loc );
2a870: e59d3010 ldr r3, [sp, #16] 2a874: e3530000 cmp r3, #0
2a878: 0a000004 beq 2a890 <rmdir+0x150>
2a87c: e593301c ldr r3, [r3, #28] 2a880: e3530000 cmp r3, #0 2a884: 11a00005 movne r0, r5 2a888: 11a0e00f movne lr, pc 2a88c: 112fff13 bxne r3
if ( free_parentloc )
2a890: e3560000 cmp r6, #0
2a894: 0a000007 beq 2a8b8 <rmdir+0x178>
rtems_filesystem_freenode( &parentloc );
2a898: e59d3024 ldr r3, [sp, #36] ; 0x24 2a89c: e3530000 cmp r3, #0
2a8a0: 0a000004 beq 2a8b8 <rmdir+0x178>
2a8a4: e593301c ldr r3, [r3, #28] 2a8a8: e3530000 cmp r3, #0 2a8ac: 11a00004 movne r0, r4 2a8b0: 11a0e00f movne lr, pc 2a8b4: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( ENOTDIR );
2a8b8: eb0061cc bl 42ff0 <__errno> 2a8bc: e3a03014 mov r3, #20 2a8c0: e5803000 str r3, [r0] 2a8c4: e3e07000 mvn r7, #0 2a8c8: eaffffe5 b 2a864 <rmdir+0x124>
parentpathlen = rtems_filesystem_dirname ( pathname );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( pathname, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path(pathname, parentpathlen,
2a8cc: e28d4018 add r4, sp, #24 2a8d0: e3a0c000 mov ip, #0 2a8d4: e1a00007 mov r0, r7 2a8d8: e1a01005 mov r1, r5 2a8dc: e3a02002 mov r2, #2 2a8e0: e1a03004 mov r3, r4 2a8e4: e58dc000 str ip, [sp] 2a8e8: ebff74fe bl 7ce8 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
2a8ec: e3500000 cmp r0, #0 2a8f0: 03a06001 moveq r6, #1
2a8f4: 0affff9d beq 2a770 <rmdir+0x30>
result = (*loc.handlers->rmnod_h)( &parentloc, &loc );
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
2a8f8: e3e07000 mvn r7, #0 2a8fc: eaffffd8 b 2a864 <rmdir+0x124>
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
2a900: e3560000 cmp r6, #0
2a904: 0afffffb beq 2a8f8 <rmdir+0x1b8>
rtems_filesystem_freenode( &parentloc );
2a908: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 2a90c: e3530000 cmp r3, #0 <== NOT EXECUTED 2a910: 0afffff8 beq 2a8f8 <rmdir+0x1b8> <== NOT EXECUTED 2a914: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 2a918: e3530000 cmp r3, #0 <== NOT EXECUTED 2a91c: 0afffff5 beq 2a8f8 <rmdir+0x1b8> <== NOT EXECUTED 2a920: e1a00004 mov r0, r4 <== NOT EXECUTED 2a924: e1a0e00f mov lr, pc <== NOT EXECUTED 2a928: e12fff13 bx r3 <== NOT EXECUTED 2a92c: e3e07000 mvn r7, #0 <== NOT EXECUTED 2a930: eaffffcb b 2a864 <rmdir+0x124> <== NOT EXECUTED
/*
* Use the filesystems rmnod to remove the node.
*/
if ( !loc.handlers->rmnod_h ){
rtems_filesystem_freenode( &loc );
2a934: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 2a938: e3530000 cmp r3, #0 <== NOT EXECUTED 2a93c: 0a000005 beq 2a958 <rmdir+0x218> <== NOT EXECUTED 2a940: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 2a944: e3530000 cmp r3, #0 <== NOT EXECUTED 2a948: 0a000002 beq 2a958 <rmdir+0x218> <== NOT EXECUTED 2a94c: e1a00005 mov r0, r5 <== NOT EXECUTED 2a950: e1a0e00f mov lr, pc <== NOT EXECUTED 2a954: e12fff13 bx r3 <== NOT EXECUTED
if ( free_parentloc )
2a958: e3560000 cmp r6, #0 <== NOT EXECUTED 2a95c: 0a000007 beq 2a980 <rmdir+0x240> <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
2a960: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED 2a964: e3530000 cmp r3, #0 <== NOT EXECUTED 2a968: 0a000004 beq 2a980 <rmdir+0x240> <== NOT EXECUTED 2a96c: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 2a970: e3530000 cmp r3, #0 <== NOT EXECUTED 2a974: 11a00004 movne r0, r4 <== NOT EXECUTED 2a978: 11a0e00f movne lr, pc <== NOT EXECUTED 2a97c: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
2a980: eb00619a bl 42ff0 <__errno> <== NOT EXECUTED 2a984: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 2a988: e5803000 str r3, [r0] <== NOT EXECUTED 2a98c: e3e07000 mvn r7, #0 <== NOT EXECUTED 2a990: eaffffb3 b 2a864 <rmdir+0x124> <== NOT EXECUTED
/*
* Verify you can remove this node as a directory.
*/
if ( !loc.ops->node_type_h ){
rtems_filesystem_freenode( &loc );
2a994: e592301c ldr r3, [r2, #28] <== NOT EXECUTED 2a998: e3530000 cmp r3, #0 <== NOT EXECUTED 2a99c: 1affffea bne 2a94c <rmdir+0x20c> <== NOT EXECUTED 2a9a0: eaffffec b 2a958 <rmdir+0x218> <== NOT EXECUTED
000134f8 <rtems_assoc_name_bad>:
sprintf(bad_buffer, "< %" PRId32 "[0x%" PRIx32 " ] >", bad_value, bad_value);
#else
static char bad_buffer[40] = "<assocnamebad.c: : BAD NAME>";
#endif
return bad_buffer;
}
134f8: e59f0000 ldr r0, [pc, #0] ; 13500 <rtems_assoc_name_bad+0x8><== NOT EXECUTED 134fc: e12fff1e bx lr <== NOT EXECUTED
00010398 <rtems_assoc_name_by_local>:
const char *rtems_assoc_name_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
10398: e92d4010 push {r4, lr}
1039c: e1a04001 mov r4, r1
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
103a0: eb000006 bl 103c0 <rtems_assoc_ptr_by_local>
if (nap)
103a4: e3500000 cmp r0, #0
103a8: 0a000001 beq 103b4 <rtems_assoc_name_by_local+0x1c>
return nap->name;
return rtems_assoc_name_bad(local_value);
}
103ac: e5900000 ldr r0, [r0]
103b0: e8bd8010 pop {r4, pc}
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
103b4: e1a00004 mov r0, r4 <== NOT EXECUTED
}
103b8: e8bd4010 pop {r4, lr} <== NOT EXECUTED
nap = rtems_assoc_ptr_by_local(ap, local_value);
if (nap)
return nap->name;
return rtems_assoc_name_bad(local_value);
103bc: ea000c4d b 134f8 <rtems_assoc_name_bad> <== NOT EXECUTED
0000e228 <rtems_assoc_ptr_by_local>:
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
e228: e92d4030 push {r4, r5, lr}
e22c: e1a04000 mov r4, r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
e230: e5900000 ldr r0, [r0]
e234: e3500000 cmp r0, #0
const rtems_assoc_t *rtems_assoc_ptr_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
e238: e1a05001 mov r5, r1
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
e23c: 01a04000 moveq r4, r0
e240: 0a000013 beq e294 <rtems_assoc_ptr_by_local+0x6c>
e244: e59f105c ldr r1, [pc, #92] ; e2a8 <rtems_assoc_ptr_by_local+0x80>
e248: eb000345 bl ef64 <strcmp>
e24c: e3500000 cmp r0, #0
e250: 13a02000 movne r2, #0
e254: 1a00000b bne e288 <rtems_assoc_ptr_by_local+0x60>
default_ap = ap++;
for ( ; ap->name; ap++)
e258: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
e25c: e3530000 cmp r3, #0 <== NOT EXECUTED
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
e260: e284300c add r3, r4, #12 <== NOT EXECUTED
for ( ; ap->name; ap++)
e264: 0a00000a beq e294 <rtems_assoc_ptr_by_local+0x6c> <== NOT EXECUTED
e268: e1a02004 mov r2, r4 <== NOT EXECUTED
e26c: e1a04003 mov r4, r3 <== NOT EXECUTED
if (ap->local_value == local_value)
e270: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
e274: e1530005 cmp r3, r5 <== NOT EXECUTED
e278: 0a000005 beq e294 <rtems_assoc_ptr_by_local+0x6c> <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
e27c: e5b4300c ldr r3, [r4, #12]!
e280: e3530000 cmp r3, #0
e284: 0a000004 beq e29c <rtems_assoc_ptr_by_local+0x74>
if (ap->local_value == local_value)
e288: e5943004 ldr r3, [r4, #4]
e28c: e1530005 cmp r3, r5
e290: 1afffff9 bne e27c <rtems_assoc_ptr_by_local+0x54>
return ap;
return default_ap;
}
e294: e1a00004 mov r0, r4
e298: e8bd8030 pop {r4, r5, pc}
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
e29c: e1a04002 mov r4, r2
if (ap->local_value == local_value)
return ap;
return default_ap;
}
e2a0: e1a00004 mov r0, r4
e2a4: e8bd8030 pop {r4, r5, pc}
0000da98 <rtems_assoc_ptr_by_remote>:
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
da98: e92d4030 push {r4, r5, lr}
da9c: e1a04000 mov r4, r0
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
daa0: e5900000 ldr r0, [r0]
daa4: e3500000 cmp r0, #0
const rtems_assoc_t *rtems_assoc_ptr_by_remote(
const rtems_assoc_t *ap,
uint32_t remote_value
)
{
daa8: e1a05001 mov r5, r1
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
daac: 01a04000 moveq r4, r0
dab0: 0a000013 beq db04 <rtems_assoc_ptr_by_remote+0x6c>
dab4: e59f105c ldr r1, [pc, #92] ; db18 <rtems_assoc_ptr_by_remote+0x80>
dab8: eb000529 bl ef64 <strcmp>
dabc: e3500000 cmp r0, #0
dac0: 13a02000 movne r2, #0
dac4: 1a00000b bne daf8 <rtems_assoc_ptr_by_remote+0x60>
default_ap = ap++;
for ( ; ap->name; ap++)
dac8: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
dacc: e3530000 cmp r3, #0 <== NOT EXECUTED
)
{
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
dad0: e284300c add r3, r4, #12 <== NOT EXECUTED
for ( ; ap->name; ap++)
dad4: 0a00000a beq db04 <rtems_assoc_ptr_by_remote+0x6c> <== NOT EXECUTED
dad8: e1a02004 mov r2, r4 <== NOT EXECUTED
dadc: e1a04003 mov r4, r3 <== NOT EXECUTED
if (ap->remote_value == remote_value)
dae0: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
dae4: e1530005 cmp r3, r5 <== NOT EXECUTED
dae8: 0a000005 beq db04 <rtems_assoc_ptr_by_remote+0x6c> <== NOT EXECUTED
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
daec: e5b4300c ldr r3, [r4, #12]!
daf0: e3530000 cmp r3, #0
daf4: 0a000004 beq db0c <rtems_assoc_ptr_by_remote+0x74>
if (ap->remote_value == remote_value)
daf8: e5943008 ldr r3, [r4, #8]
dafc: e1530005 cmp r3, r5
db00: 1afffff9 bne daec <rtems_assoc_ptr_by_remote+0x54>
return ap;
return default_ap;
}
db04: e1a00004 mov r0, r4
db08: e8bd8030 pop {r4, r5, pc}
const rtems_assoc_t *default_ap = 0;
if (rtems_assoc_is_default(ap))
default_ap = ap++;
for ( ; ap->name; ap++)
db0c: e1a04002 mov r4, r2
if (ap->remote_value == remote_value)
return ap;
return default_ap;
}
db10: e1a00004 mov r0, r4
db14: e8bd8030 pop {r4, r5, pc}
0000e214 <rtems_assoc_remote_by_local>:
uint32_t rtems_assoc_remote_by_local(
const rtems_assoc_t *ap,
uint32_t local_value
)
{
e214: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
const rtems_assoc_t *nap;
nap = rtems_assoc_ptr_by_local(ap, local_value);
e218: eb000002 bl e228 <rtems_assoc_ptr_by_local> <== NOT EXECUTED
if (nap)
e21c: e3500000 cmp r0, #0 <== NOT EXECUTED
return nap->remote_value;
e220: 15900008 ldrne r0, [r0, #8] <== NOT EXECUTED
return 0;
}
e224: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0000aa4c <rtems_bdbuf_add_to_modified_list_after_access>:
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
aa4c: e92d4030 push {r4, r5, lr}
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
aa50: e59f50b8 ldr r5, [pc, #184] ; ab10 <rtems_bdbuf_add_to_modified_list_after_access+0xc4>
aa54: e5d53030 ldrb r3, [r5, #48] ; 0x30
aa58: e3530000 cmp r3, #0
}
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
aa5c: e1a04000 mov r4, r0
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
aa60: 0a000004 beq aa78 <rtems_bdbuf_add_to_modified_list_after_access+0x2c>
aa64: e2853038 add r3, r5, #56 ; 0x38 <== NOT EXECUTED
aa68: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
aa6c: e5901014 ldr r1, [r0, #20] <== NOT EXECUTED
aa70: e1510002 cmp r1, r2 <== NOT EXECUTED
aa74: 0a00001a beq aae4 <rtems_bdbuf_add_to_modified_list_after_access+0x98><== NOT EXECUTED
* nothing being written? We have tended to think we should hold changes for
* only a specific period of time even if still changing and get onto disk
* and letting the file system try and recover this position if it can.
*/
if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
aa78: e5943024 ldr r3, [r4, #36] ; 0x24
* difficult question. Is a snapshot of a block that is changing better than * nothing being written? We have tended to think we should hold changes for * only a specific period of time even if still changing and get onto disk * and letting the file system try and recover this position if it can. */ if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
aa7c: e3530003 cmp r3, #3
aa80: 0a000010 beq aac8 <rtems_bdbuf_add_to_modified_list_after_access+0x7c>
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
aa84: e5943024 ldr r3, [r4, #36] ; 0x24
* difficult question. Is a snapshot of a block that is changing better than * nothing being written? We have tended to think we should hold changes for * only a specific period of time even if still changing and get onto disk * and letting the file system try and recover this position if it can. */ if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
aa88: e3530005 cmp r3, #5
aa8c: 0a00000d beq aac8 <rtems_bdbuf_add_to_modified_list_after_access+0x7c>
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
aa90: e59f5078 ldr r5, [pc, #120] ; ab10 <rtems_bdbuf_add_to_modified_list_after_access+0xc4>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
aa94: e3a03007 mov r3, #7
aa98: e5843024 str r3, [r4, #36] ; 0x24
aa9c: e2850050 add r0, r5, #80 ; 0x50
aaa0: e1a01004 mov r1, r4
aaa4: ebfff2bf bl 75a8 <_Chain_Append>
bd->hold_timer = bdbuf_config.swap_block_hold;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
aaa8: e5943028 ldr r3, [r4, #40] ; 0x28
aaac: e3530000 cmp r3, #0
aab0: 1a000008 bne aad8 <rtems_bdbuf_add_to_modified_list_after_access+0x8c>
}
static bool
rtems_bdbuf_has_buffer_waiters (void)
{
return bdbuf_cache.buffer_waiters.count;
aab4: e5953078 ldr r3, [r5, #120] ; 0x78
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else if (rtems_bdbuf_has_buffer_waiters ())
aab8: e3530000 cmp r3, #0
aabc: 08bd8030 popeq {r4, r5, pc}
rtems_bdbuf_wake_swapper ();
}
aac0: e8bd4030 pop {r4, r5, lr}
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
aac4: eaffffd5 b aa20 <rtems_bdbuf_wake_swapper>
* only a specific period of time even if still changing and get onto disk
* and letting the file system try and recover this position if it can.
*/
if (bd->state == RTEMS_BDBUF_STATE_ACCESS_CACHED
|| bd->state == RTEMS_BDBUF_STATE_ACCESS_EMPTY)
bd->hold_timer = bdbuf_config.swap_block_hold;
aac8: e59f3044 ldr r3, [pc, #68] ; ab14 <rtems_bdbuf_add_to_modified_list_after_access+0xc8>
aacc: e5933010 ldr r3, [r3, #16]
aad0: e5843030 str r3, [r4, #48] ; 0x30
aad4: eaffffed b aa90 <rtems_bdbuf_add_to_modified_list_after_access+0x44>
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
aad8: e2850068 add r0, r5, #104 ; 0x68
else if (rtems_bdbuf_has_buffer_waiters ())
rtems_bdbuf_wake_swapper ();
}
aadc: e8bd4030 pop {r4, r5, lr}
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_MODIFIED);
rtems_chain_append (&bdbuf_cache.modified, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
aae0: eaffff00 b a6e8 <rtems_bdbuf_wake>
}
static void
rtems_bdbuf_add_to_modified_list_after_access (rtems_bdbuf_buffer *bd)
{
if (bdbuf_cache.sync_active && bdbuf_cache.sync_device == bd->dev)
aae4: e5901018 ldr r1, [r0, #24] <== NOT EXECUTED
aae8: e1510003 cmp r1, r3 <== NOT EXECUTED
aaec: 1affffe1 bne aa78 <rtems_bdbuf_add_to_modified_list_after_access+0x2c><== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
aaf0: ebffff71 bl a8bc <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
* Lock the cache's sync. A single task can nest calls.
*/
static void
rtems_bdbuf_lock_sync (void)
{
rtems_bdbuf_lock (bdbuf_cache.sync_lock, RTEMS_BLKDEV_FATAL_BDBUF_SYNC_LOCK);
aaf4: e3a01442 mov r1, #1107296256 ; 0x42000000 <== NOT EXECUTED
aaf8: e595002c ldr r0, [r5, #44] ; 0x2c <== NOT EXECUTED
aafc: e281100b add r1, r1, #11 <== NOT EXECUTED
ab00: ebfffee9 bl a6ac <rtems_bdbuf_lock> <== NOT EXECUTED
/*
* Wait for the sync lock.
*/
rtems_bdbuf_lock_sync ();
rtems_bdbuf_unlock_sync ();
ab04: ebffff76 bl a8e4 <rtems_bdbuf_unlock_sync> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
ab08: ebfffef0 bl a6d0 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
ab0c: eaffffd9 b aa78 <rtems_bdbuf_add_to_modified_list_after_access+0x2c><== NOT EXECUTED
0000ac84 <rtems_bdbuf_anonymous_wait>:
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
ac84: e5903000 ldr r3, [r0]
ac88: e2833001 add r3, r3, #1
* The function assumes the cache is locked on entry and it will be locked on
* exit.
*/
static void
rtems_bdbuf_anonymous_wait (rtems_bdbuf_waiters *waiters)
{
ac8c: e92d4030 push {r4, r5, lr}
rtems_mode prev_mode;
/*
* Indicate we are waiting.
*/
++waiters->count;
ac90: e5803000 str r3, [r0]
* The function assumes the cache is locked on entry and it will be locked on
* exit.
*/
static void
rtems_bdbuf_anonymous_wait (rtems_bdbuf_waiters *waiters)
{
ac94: e1a04000 mov r4, r0
* blocking or just hits that window, and before this task has blocked on the * semaphore. If the preempting task flushes the queue this task will not see * the flush and may block for ever or until another transaction flushes this * semaphore. */ prev_mode = rtems_bdbuf_disable_preemption ();
ac98: ebffffd9 bl ac04 <rtems_bdbuf_disable_preemption>
ac9c: e1a05000 mov r5, r0
/*
* Unlock the cache, wait, and lock the cache when we return.
*/
rtems_bdbuf_unlock_cache ();
aca0: ebffff05 bl a8bc <rtems_bdbuf_unlock_cache>
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
aca4: e3a01000 mov r1, #0
aca8: e5940004 ldr r0, [r4, #4]
acac: e1a02001 mov r2, r1
acb0: ebffef98 bl 6b18 <rtems_semaphore_obtain>
if (sc == RTEMS_TIMEOUT)
acb4: e3500006 cmp r0, #6
acb8: 0a000008 beq ace0 <rtems_bdbuf_anonymous_wait+0x5c>
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO);
if (sc != RTEMS_UNSATISFIED)
acbc: e350000d cmp r0, #13
acc0: 1a000009 bne acec <rtems_bdbuf_anonymous_wait+0x68>
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_2);
rtems_bdbuf_lock_cache ();
acc4: ebfffe81 bl a6d0 <rtems_bdbuf_lock_cache>
rtems_bdbuf_restore_preemption (prev_mode);
acc8: e1a00005 mov r0, r5
accc: ebffffdd bl ac48 <rtems_bdbuf_restore_preemption>
--waiters->count;
acd0: e5943000 ldr r3, [r4]
acd4: e2433001 sub r3, r3, #1
acd8: e5843000 str r3, [r4]
}
acdc: e8bd8030 pop {r4, r5, pc}
rtems_bdbuf_unlock_cache ();
sc = rtems_semaphore_obtain (waiters->sema, RTEMS_WAIT, RTEMS_BDBUF_WAIT_TIMEOUT);
if (sc == RTEMS_TIMEOUT)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_TO);
ace0: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
ace4: e2800012 add r0, r0, #18 <== NOT EXECUTED
ace8: ebfff102 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
if (sc != RTEMS_UNSATISFIED)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAIT_2);
acec: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
acf0: e2800010 add r0, r0, #16 <== NOT EXECUTED
acf4: ebfff0ff bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000ac04 <rtems_bdbuf_disable_preemption>:
--bd->group->users;
}
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
ac04: e52de004 push {lr} ; (str lr, [sp, #-4]!)
ac08: e24dd004 sub sp, sp, #4
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_mode prev_mode = 0;
ac0c: e28d2004 add r2, sp, #4
ac10: e3a03000 mov r3, #0
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
ac14: e3a00c01 mov r0, #256 ; 0x100
static rtems_mode
rtems_bdbuf_disable_preemption (void)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_mode prev_mode = 0;
ac18: e5223004 str r3, [r2, #-4]!
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
ac1c: e1a01000 mov r1, r0
ac20: e1a0200d mov r2, sp
ac24: eb00124d bl f560 <rtems_task_mode>
if (sc != RTEMS_SUCCESSFUL)
ac28: e3500000 cmp r0, #0
ac2c: 1a000002 bne ac3c <rtems_bdbuf_disable_preemption+0x38>
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_DIS);
return prev_mode;
}
ac30: e59d0000 ldr r0, [sp]
ac34: e28dd004 add sp, sp, #4
ac38: e8bd8000 pop {pc}
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_mode prev_mode = 0;
sc = rtems_task_mode (RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &prev_mode);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_DIS);
ac3c: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
ac40: e280000f add r0, r0, #15 <== NOT EXECUTED
ac44: ebfff12b bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000c78c <rtems_bdbuf_get>:
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
c78c: e92d40f0 push {r4, r5, r6, r7, lr}
c790: e24dd014 sub sp, sp, #20
rtems_disk_device *dd = NULL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
c794: e28de00c add lr, sp, #12
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
c798: e3a0c000 mov ip, #0
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
c79c: e58de000 str lr, [sp]
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
c7a0: e1a07003 mov r7, r3
rtems_disk_device *dd = NULL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
c7a4: e28de008 add lr, sp, #8
c7a8: e28d3010 add r3, sp, #16
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
c7ac: e58dc008 str ip, [sp, #8]
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
c7b0: e58de004 str lr, [sp, #4]
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
c7b4: e58dc010 str ip, [sp, #16]
rtems_bdbuf_buffer *bd = NULL; rtems_blkdev_bnum media_block = 0;
c7b8: e58dc00c str ip, [sp, #12]
rtems_status_code
rtems_bdbuf_get (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
c7bc: e1a05000 mov r5, r0
c7c0: e1a06001 mov r6, r1
rtems_disk_device *dd = NULL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
c7c4: ebfff850 bl a90c <rtems_bdbuf_obtain_disk>
if (sc != RTEMS_SUCCESSFUL)
c7c8: e2504000 subs r4, r0, #0
c7cc: 0a000002 beq c7dc <rtems_bdbuf_get+0x50>
rtems_bdbuf_release_disk (dd);
*bd_ptr = bd;
return RTEMS_SUCCESSFUL;
}
c7d0: e1a00004 mov r0, r4
c7d4: e28dd014 add sp, sp, #20
c7d8: e8bd80f0 pop {r4, r5, r6, r7, pc}
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_bdbuf_lock_cache ();
c7dc: ebfff7bb bl a6d0 <rtems_bdbuf_lock_cache>
*/
if (rtems_bdbuf_tracer)
printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block, block, (unsigned) dev);
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
c7e0: e1a00005 mov r0, r5
c7e4: e59d3008 ldr r3, [sp, #8]
c7e8: e1a01006 mov r1, r6
c7ec: e59d200c ldr r2, [sp, #12]
c7f0: ebffff53 bl c544 <rtems_bdbuf_get_buffer_for_access>
switch (bd->state)
c7f4: e5903024 ldr r3, [r0, #36] ; 0x24
c7f8: e3530002 cmp r3, #2
*/
if (rtems_bdbuf_tracer)
printf ("bdbuf:get: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block, block, (unsigned) dev);
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
c7fc: e1a05000 mov r5, r0
switch (bd->state)
c800: 0a00000f beq c844 <rtems_bdbuf_get+0xb8>
c804: e3530007 cmp r3, #7
c808: 0a000006 beq c828 <rtems_bdbuf_get+0x9c>
c80c: e3530001 cmp r3, #1
c810: 0a00000e beq c850 <rtems_bdbuf_get+0xc4>
* so just gets the block to fill.
*/
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_2);
c814: e5900024 ldr r0, [r0, #36] ; 0x24 <== NOT EXECUTED
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
c818: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
c81c: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
c820: e380001e orr r0, r0, #30 <== NOT EXECUTED
c824: ebffea33 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c828: e3a03004 mov r3, #4
c82c: e5803024 str r3, [r0, #36] ; 0x24
{
rtems_bdbuf_show_users ("get", bd);
rtems_bdbuf_show_usage ();
}
rtems_bdbuf_unlock_cache ();
c830: ebfff821 bl a8bc <rtems_bdbuf_unlock_cache>
rtems_bdbuf_release_disk (dd);
c834: e59d0010 ldr r0, [sp, #16]
c838: ebfff871 bl aa04 <rtems_bdbuf_release_disk>
*bd_ptr = bd;
c83c: e5875000 str r5, [r7]
return RTEMS_SUCCESSFUL;
c840: eaffffe2 b c7d0 <rtems_bdbuf_get+0x44>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c844: e3a03003 mov r3, #3
c848: e5803024 str r3, [r0, #36] ; 0x24
switch (bd->state)
{
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);
break;
c84c: eafffff7 b c830 <rtems_bdbuf_get+0xa4>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c850: e3a03005 mov r3, #5
c854: e5803024 str r3, [r0, #36] ; 0x24
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_CACHED);
break;
case RTEMS_BDBUF_STATE_EMPTY:
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_EMPTY);
break;
c858: eafffff4 b c830 <rtems_bdbuf_get+0xa4>
0000c544 <rtems_bdbuf_get_buffer_for_access>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_for_access (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
c544: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr}
c548: e59f7220 ldr r7, [pc, #544] ; c770 <rtems_bdbuf_get_buffer_for_access+0x22c>
c54c: e1a04000 mov r4, r0
c550: e1a05001 mov r5, r1
c554: e1a06002 mov r6, r2
c558: e1a08003 mov r8, r3
static rtems_bdbuf_buffer *
rtems_bdbuf_avl_search (rtems_bdbuf_buffer** root,
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
c55c: e597a040 ldr sl, [r7, #64] ; 0x40
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
c560: e35a0000 cmp sl, #0
c564: 0a000008 beq c58c <rtems_bdbuf_get_buffer_for_access+0x48>
c568: e59a3014 ldr r3, [sl, #20]
c56c: e1540003 cmp r4, r3
c570: e59a2018 ldr r2, [sl, #24]
c574: 0a000017 beq c5d8 <rtems_bdbuf_get_buffer_for_access+0x94>
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
c578: e1550002 cmp r5, r2
c57c: 9a000010 bls c5c4 <rtems_bdbuf_get_buffer_for_access+0x80>
{
p = p->avl.right;
c580: e59aa00c ldr sl, [sl, #12]
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
c584: e35a0000 cmp sl, #0
c588: 1afffff6 bne c568 <rtems_bdbuf_get_buffer_for_access+0x24>
bd = NULL;
}
}
else
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
c58c: e1a00004 mov r0, r4
c590: e1a01005 mov r1, r5
c594: e1a02006 mov r2, r6
c598: e1a03008 mov r3, r8
c59c: ebfffeee bl c15c <rtems_bdbuf_get_buffer_from_lru_list>
if (bd == NULL)
c5a0: e250a000 subs sl, r0, #0
c5a4: 1a000017 bne c608 <rtems_bdbuf_get_buffer_for_access+0xc4>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
c5a8: e5972050 ldr r2, [r7, #80] ; 0x50
c5ac: e59f31c0 ldr r3, [pc, #448] ; c774 <rtems_bdbuf_get_buffer_for_access+0x230>
c5b0: e1520003 cmp r2, r3
static void
rtems_bdbuf_wait_for_buffer (void)
{
if (!rtems_chain_is_empty (&bdbuf_cache.modified))
rtems_bdbuf_wake_swapper ();
c5b4: 1bfff919 blne aa20 <rtems_bdbuf_wake_swapper>
rtems_bdbuf_anonymous_wait (&bdbuf_cache.buffer_waiters);
c5b8: e59f01b8 ldr r0, [pc, #440] ; c778 <rtems_bdbuf_get_buffer_for_access+0x234>
c5bc: ebfff9b0 bl ac84 <rtems_bdbuf_anonymous_wait>
c5c0: eaffffe5 b c55c <rtems_bdbuf_get_buffer_for_access+0x18>
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
c5c4: 1a000001 bne c5d0 <rtems_bdbuf_get_buffer_for_access+0x8c>
c5c8: e1540003 cmp r4, r3
c5cc: 8affffeb bhi c580 <rtems_bdbuf_get_buffer_for_access+0x3c>
{
p = p->avl.right;
}
else
{
p = p->avl.left;
c5d0: e59aa008 ldr sl, [sl, #8]
c5d4: eaffffea b c584 <rtems_bdbuf_get_buffer_for_access+0x40>
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
c5d8: e1550002 cmp r5, r2
c5dc: 1affffe5 bne c578 <rtems_bdbuf_get_buffer_for_access+0x34>
c5e0: e59a301c ldr r3, [sl, #28]
c5e4: e1560003 cmp r6, r3
c5e8: 0a000002 beq c5f8 <rtems_bdbuf_get_buffer_for_access+0xb4>
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
c5ec: 8affffe3 bhi c580 <rtems_bdbuf_get_buffer_for_access+0x3c>
{
p = p->avl.right;
}
else
{
p = p->avl.left;
c5f0: e59aa008 ldr sl, [sl, #8]
c5f4: eaffffe2 b c584 <rtems_bdbuf_get_buffer_for_access+0x40>
{
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
if (bd != NULL)
{
if (bd->group->bds_per_group != bds_per_group)
c5f8: e59a302c ldr r3, [sl, #44] ; 0x2c
c5fc: e5933008 ldr r3, [r3, #8]
c600: e1530008 cmp r3, r8
c604: 1a000027 bne c6a8 <rtems_bdbuf_get_buffer_for_access+0x164>
static void
rtems_bdbuf_wait_for_access (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
c608: e59a3024 ldr r3, [sl, #36] ; 0x24
c60c: e2433001 sub r3, r3, #1
c610: e3530009 cmp r3, #9
c614: 979ff103 ldrls pc, [pc, r3, lsl #2]
c618: ea00001d b c694 <rtems_bdbuf_get_buffer_for_access+0x150> <== NOT EXECUTED
c61c: 0000c65c .word 0x0000c65c <== NOT EXECUTED
c620: 0000c654 .word 0x0000c654 <== NOT EXECUTED
c624: 0000c674 .word 0x0000c674 <== NOT EXECUTED
c628: 0000c674 .word 0x0000c674 <== NOT EXECUTED
c62c: 0000c674 .word 0x0000c674 <== NOT EXECUTED
c630: 0000c674 .word 0x0000c674 <== NOT EXECUTED
c634: 0000c644 .word 0x0000c644 <== NOT EXECUTED
c638: 0000c684 .word 0x0000c684 <== NOT EXECUTED
c63c: 0000c684 .word 0x0000c684 <== NOT EXECUTED
c640: 0000c684 .word 0x0000c684 <== NOT EXECUTED
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
c644: e59a302c ldr r3, [sl, #44] ; 0x2c
c648: e593200c ldr r2, [r3, #12]
c64c: e2422001 sub r2, r2, #1
c650: e583200c str r2, [r3, #12]
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
c654: e1a0000a mov r0, sl
c658: ebffebdd bl 75d4 <_Chain_Extract>
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
c65c: e59a302c ldr r3, [sl, #44] ; 0x2c
c660: e593200c ldr r2, [r3, #12]
c664: e2822001 add r2, r2, #1
c668: e583200c str r2, [r3, #12]
rtems_bdbuf_wait_for_access (bd);
rtems_bdbuf_group_obtain (bd);
return bd;
}
c66c: e1a0000a mov r0, sl
c670: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc}
return;
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
c674: e1a0000a mov r0, sl
c678: e59f10fc ldr r1, [pc, #252] ; c77c <rtems_bdbuf_get_buffer_for_access+0x238>
c67c: ebfff99d bl acf8 <rtems_bdbuf_wait>
c680: eaffffe0 b c608 <rtems_bdbuf_get_buffer_for_access+0xc4>
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
c684: e1a0000a mov r0, sl
c688: e59f10f0 ldr r1, [pc, #240] ; c780 <rtems_bdbuf_get_buffer_for_access+0x23c>
c68c: ebfff999 bl acf8 <rtems_bdbuf_wait>
c690: eaffffdc b c608 <rtems_bdbuf_get_buffer_for_access+0xc4>
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_7);
c694: e59a0024 ldr r0, [sl, #36] ; 0x24 <== NOT EXECUTED
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
c698: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
c69c: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
c6a0: e3800005 orr r0, r0, #5 <== NOT EXECUTED
c6a4: ebffea93 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c6a8: e3a09008 mov r9, #8
static bool
rtems_bdbuf_wait_for_recycle (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
c6ac: e59a3024 ldr r3, [sl, #36] ; 0x24
c6b0: e353000a cmp r3, #10
c6b4: 979ff103 ldrls pc, [pc, r3, lsl #2]
c6b8: ea000027 b c75c <rtems_bdbuf_get_buffer_for_access+0x218> <== NOT EXECUTED
c6bc: 0000c734 .word 0x0000c734 <== NOT EXECUTED
c6c0: 0000c728 .word 0x0000c728 <== NOT EXECUTED
c6c4: 0000c728 .word 0x0000c728 <== NOT EXECUTED
c6c8: 0000c718 .word 0x0000c718 <== NOT EXECUTED
c6cc: 0000c718 .word 0x0000c718 <== NOT EXECUTED
c6d0: 0000c718 .word 0x0000c718 <== NOT EXECUTED
c6d4: 0000c718 .word 0x0000c718 <== NOT EXECUTED
c6d8: 0000c6f8 .word 0x0000c6f8 <== NOT EXECUTED
c6dc: 0000c6e8 .word 0x0000c6e8 <== NOT EXECUTED
c6e0: 0000c6e8 .word 0x0000c6e8 <== NOT EXECUTED
c6e4: 0000c6e8 .word 0x0000c6e8 <== NOT EXECUTED
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
break;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
c6e8: e1a0000a mov r0, sl <== NOT EXECUTED
c6ec: e59f108c ldr r1, [pc, #140] ; c780 <rtems_bdbuf_get_buffer_for_access+0x23c><== NOT EXECUTED
c6f0: ebfff980 bl acf8 <rtems_bdbuf_wait> <== NOT EXECUTED
c6f4: eaffffec b c6ac <rtems_bdbuf_get_buffer_for_access+0x168> <== NOT EXECUTED
c6f8: e1a0000a mov r0, sl <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c6fc: e58a9024 str r9, [sl, #36] ; 0x24 <== NOT EXECUTED
c700: ebffebb3 bl 75d4 <_Chain_Extract> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
c704: e59f0078 ldr r0, [pc, #120] ; c784 <rtems_bdbuf_get_buffer_for_access+0x240><== NOT EXECUTED
c708: e1a0100a mov r1, sl <== NOT EXECUTED
c70c: ebffeba5 bl 75a8 <_Chain_Append> <== NOT EXECUTED
rtems_bdbuf_request_sync_for_modified_buffer (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_extract (&bd->link);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
rtems_bdbuf_wake_swapper ();
c710: ebfff8c2 bl aa20 <rtems_bdbuf_wake_swapper> <== NOT EXECUTED
c714: eaffffe4 b c6ac <rtems_bdbuf_get_buffer_for_access+0x168> <== NOT EXECUTED
}
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.access_waiters);
c718: e1a0000a mov r0, sl
c71c: e59f1058 ldr r1, [pc, #88] ; c77c <rtems_bdbuf_get_buffer_for_access+0x238>
c720: ebfff974 bl acf8 <rtems_bdbuf_wait>
c724: eaffffe0 b c6ac <rtems_bdbuf_get_buffer_for_access+0x168>
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_request_sync_for_modified_buffer (bd);
break;
case RTEMS_BDBUF_STATE_CACHED:
case RTEMS_BDBUF_STATE_EMPTY:
if (bd->waiters == 0)
c728: e59a3028 ldr r3, [sl, #40] ; 0x28
c72c: e3530000 cmp r3, #0
c730: 1affffa0 bne c5b8 <rtems_bdbuf_get_buffer_for_access+0x74>
{
if (bd->group->bds_per_group != bds_per_group)
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
c734: e1a0000a mov r0, sl <== NOT EXECUTED
c738: ebfffb64 bl b4d0 <rtems_bdbuf_remove_from_tree_and_lru_list><== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c73c: e3a03000 mov r3, #0 <== NOT EXECUTED
c740: e58a3024 str r3, [sl, #36] ; 0x24 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
c744: e1a0100a mov r1, sl <== NOT EXECUTED
c748: e59f0038 ldr r0, [pc, #56] ; c788 <rtems_bdbuf_get_buffer_for_access+0x244><== NOT EXECUTED
c74c: eb000cb1 bl fa18 <_Chain_Insert> <== NOT EXECUTED
{
if (rtems_bdbuf_wait_for_recycle (bd))
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
c750: e59f0020 ldr r0, [pc, #32] ; c778 <rtems_bdbuf_get_buffer_for_access+0x234><== NOT EXECUTED
c754: ebfff7e3 bl a6e8 <rtems_bdbuf_wake> <== NOT EXECUTED
c758: eaffff7f b c55c <rtems_bdbuf_get_buffer_for_access+0x18> <== NOT EXECUTED
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_8);
c75c: e59a0024 ldr r0, [sl, #36] ; 0x24 <== NOT EXECUTED
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
c760: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
c764: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
c768: e3800006 orr r0, r0, #6 <== NOT EXECUTED
c76c: ebffea61 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000c15c <rtems_bdbuf_get_buffer_from_lru_list>:
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
c15c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return the_chain->first;
c160: e59fc3cc ldr ip, [pc, #972] ; c534 <rtems_bdbuf_get_buffer_from_lru_list+0x3d8>
c164: e59c4044 ldr r4, [ip, #68] ; 0x44
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
c168: e59fc3c8 ldr ip, [pc, #968] ; c538 <rtems_bdbuf_get_buffer_from_lru_list+0x3dc>
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
c16c: e24dd088 sub sp, sp, #136 ; 0x88
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
c170: e154000c cmp r4, ip
static rtems_bdbuf_buffer *
rtems_bdbuf_get_buffer_from_lru_list (dev_t dev,
rtems_blkdev_bnum block,
size_t bds_per_group)
{
c174: e58d0004 str r0, [sp, #4]
c178: e1a05001 mov r5, r1
c17c: e58d2000 str r2, [sp]
c180: e1a0b003 mov fp, r3
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
c184: 0a00003a beq c274 <rtems_bdbuf_get_buffer_from_lru_list+0x118>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c188: e3a09000 mov r9, #0
bd->group->bds_per_group, bds_per_group);
/*
* If nobody waits for this BD, we may recycle it.
*/
if (bd->waiters == 0)
c18c: e5943028 ldr r3, [r4, #40] ; 0x28
c190: e3530000 cmp r3, #0
c194: 1a000032 bne c264 <rtems_bdbuf_get_buffer_from_lru_list+0x108>
{
if (bd->group->bds_per_group == bds_per_group)
c198: e594802c ldr r8, [r4, #44] ; 0x2c
c19c: e5981008 ldr r1, [r8, #8]
c1a0: e151000b cmp r1, fp
c1a4: 0a000036 beq c284 <rtems_bdbuf_get_buffer_from_lru_list+0x128>
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
empty_bd = bd;
}
else if (bd->group->users == 0)
c1a8: e598a00c ldr sl, [r8, #12]
c1ac: e35a0000 cmp sl, #0
c1b0: 1a00002b bne c264 <rtems_bdbuf_get_buffer_from_lru_list+0x108>
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
c1b4: e5987010 ldr r7, [r8, #16]
if (rtems_bdbuf_tracer)
printf ("bdbuf:realloc: %tu: %zd -> %zd\n",
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
c1b8: e59f3374 ldr r3, [pc, #884] ; c534 <rtems_bdbuf_get_buffer_from_lru_list+0x3d8>
for (b = 0, bd = group->bdbuf;
c1bc: e3510000 cmp r1, #0
if (rtems_bdbuf_tracer)
printf ("bdbuf:realloc: %tu: %zd -> %zd\n",
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
c1c0: e5930020 ldr r0, [r3, #32]
for (b = 0, bd = group->bdbuf;
c1c4: e1a06007 mov r6, r7
c1c8: 0a00000c beq c200 <rtems_bdbuf_get_buffer_from_lru_list+0xa4>
c1cc: eb003d26 bl 1b66c <__aeabi_uidiv>
c1d0: e1a06100 lsl r6, r0, #2
c1d4: e0666300 rsb r6, r6, r0, lsl #6
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
c1d8: e1a00007 mov r0, r7
c1dc: ebfffcbb bl b4d0 <rtems_bdbuf_remove_from_tree_and_lru_list>
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
c1e0: e5983008 ldr r3, [r8, #8]
b < group->bds_per_group;
b++, bd += bufs_per_bd)
c1e4: e28aa001 add sl, sl, #1
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
c1e8: e15a0003 cmp sl, r3
b < group->bds_per_group;
b++, bd += bufs_per_bd)
c1ec: e0877006 add r7, r7, r6
group - bdbuf_cache.groups, group->bds_per_group,
new_bds_per_group);
bufs_per_bd = bdbuf_cache.max_bds_per_group / group->bds_per_group;
for (b = 0, bd = group->bdbuf;
c1f0: 3afffff8 bcc c1d8 <rtems_bdbuf_get_buffer_from_lru_list+0x7c>
c1f4: e59fc338 ldr ip, [pc, #824] ; c534 <rtems_bdbuf_get_buffer_from_lru_list+0x3d8>
c1f8: e5986010 ldr r6, [r8, #16]
c1fc: e59c0020 ldr r0, [ip, #32]
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
c200: e35b0001 cmp fp, #1
for (b = 0, bd = group->bdbuf;
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
c204: e588b008 str fp, [r8, #8]
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
c208: e1a02006 mov r2, r6
c20c: 9a000012 bls c25c <rtems_bdbuf_get_buffer_from_lru_list+0x100>
c210: e1a0100b mov r1, fp
c214: eb003d14 bl 1b66c <__aeabi_uidiv>
c218: e1a0a100 lsl sl, r0, #2
c21c: e06aa300 rsb sl, sl, r0, lsl #6
c220: e086600a add r6, r6, sl
c224: e3a07001 mov r7, #1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c228: e5869024 str r9, [r6, #36] ; 0x24
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
c22c: e1a01006 mov r1, r6
c230: e59f0304 ldr r0, [pc, #772] ; c53c <rtems_bdbuf_get_buffer_from_lru_list+0x3e0>
c234: eb000df7 bl fa18 <_Chain_Insert>
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
c238: e5983008 ldr r3, [r8, #8]
b < group->bds_per_group;
b++, bd += bufs_per_bd)
c23c: e2877001 add r7, r7, #1
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
c240: e1570003 cmp r7, r3
b < group->bds_per_group;
b++, bd += bufs_per_bd)
c244: e086600a add r6, r6, sl
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
group->bds_per_group = new_bds_per_group;
bufs_per_bd = bdbuf_cache.max_bds_per_group / new_bds_per_group;
for (b = 1, bd = group->bdbuf + bufs_per_bd;
c248: 3afffff6 bcc c228 <rtems_bdbuf_get_buffer_from_lru_list+0xcc>
b < group->bds_per_group;
b++, bd += bufs_per_bd)
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
if (b > 1)
c24c: e3570001 cmp r7, #1
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
c250: 859f02e8 ldrhi r0, [pc, #744] ; c540 <rtems_bdbuf_get_buffer_from_lru_list+0x3e4>
c254: 8bfff923 blhi a6e8 <rtems_bdbuf_wake>
c258: e5982010 ldr r2, [r8, #16]
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, bds_per_group);
}
if (empty_bd != NULL)
c25c: e3520000 cmp r2, #0
c260: 1a00000c bne c298 <rtems_bdbuf_get_buffer_from_lru_list+0x13c>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
c264: e5944000 ldr r4, [r4]
rtems_blkdev_bnum block,
size_t bds_per_group)
{
rtems_chain_node *node = rtems_chain_first (&bdbuf_cache.lru);
while (!rtems_chain_is_tail (&bdbuf_cache.lru, node))
c268: e59f12c8 ldr r1, [pc, #712] ; c538 <rtems_bdbuf_get_buffer_from_lru_list+0x3dc>
c26c: e1540001 cmp r4, r1
c270: 1affffc5 bne c18c <rtems_bdbuf_get_buffer_from_lru_list+0x30>
c274: e3a02000 mov r2, #0
node = rtems_chain_next (node);
}
return NULL;
}
c278: e1a00002 mov r0, r2
c27c: e28dd088 add sp, sp, #136 ; 0x88
c280: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
*/
if (bd->waiters == 0)
{
if (bd->group->bds_per_group == bds_per_group)
{
rtems_bdbuf_remove_from_tree_and_lru_list (bd);
c284: e1a00004 mov r0, r4
c288: ebfffc90 bl b4d0 <rtems_bdbuf_remove_from_tree_and_lru_list>
c28c: e1a02004 mov r2, r4
}
else if (bd->group->users == 0)
empty_bd = rtems_bdbuf_group_realloc (bd->group, bds_per_group);
}
if (empty_bd != NULL)
c290: e3520000 cmp r2, #0
c294: 0afffff2 beq c264 <rtems_bdbuf_get_buffer_from_lru_list+0x108>
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
bd->block = block;
bd->avl.left = NULL;
c298: e3a01000 mov r1, #0
c29c: e5821008 str r1, [r2, #8]
bd->avl.right = NULL;
c2a0: e582100c str r1, [r2, #12]
rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
c2a4: e59f0288 ldr r0, [pc, #648] ; c534 <rtems_bdbuf_get_buffer_from_lru_list+0x3d8>
c2a8: e5903040 ldr r3, [r0, #64] ; 0x40
{
bd->dev = dev;
bd->block = block;
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
c2ac: e5821028 str r1, [r2, #40] ; 0x28
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
c2b0: e1530001 cmp r3, r1
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
bd->block = block;
c2b4: e59dc000 ldr ip, [sp]
static void
rtems_bdbuf_setup_empty_buffer (rtems_bdbuf_buffer *bd,
dev_t dev,
rtems_blkdev_bnum block)
{
bd->dev = dev;
c2b8: e59d1004 ldr r1, [sp, #4]
c2bc: e5825018 str r5, [r2, #24]
c2c0: e5821014 str r1, [r2, #20]
bd->block = block;
c2c4: e582c01c str ip, [r2, #28]
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
if (p == NULL)
c2c8: 0a000093 beq c51c <rtems_bdbuf_get_buffer_from_lru_list+0x3c0>
c2cc: e28d7008 add r7, sp, #8
c2d0: e1a0c007 mov ip, r7
break;
}
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
c2d4: e3e08000 mvn r8, #0
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
{
p->avl.cache = 1;
c2d8: e3a06001 mov r6, #1
c2dc: e59da000 ldr sl, [sp]
c2e0: e1a04001 mov r4, r1
c2e4: ea00000a b c314 <rtems_bdbuf_get_buffer_from_lru_list+0x1b8>
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
c2e8: 1a000001 bne c2f4 <rtems_bdbuf_get_buffer_from_lru_list+0x198>
c2ec: e1540009 cmp r4, r9
c2f0: 8a00000d bhi c32c <rtems_bdbuf_get_buffer_from_lru_list+0x1d0>
c2f4: e1540009 cmp r4, r9
c2f8: 0a000059 beq c464 <rtems_bdbuf_get_buffer_from_lru_list+0x308>
}
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
q = p->avl.left;
c2fc: e5930008 ldr r0, [r3, #8]
if (q == NULL)
c300: e3500000 cmp r0, #0
break;
}
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
c304: e5c38010 strb r8, [r3, #16]
q = p->avl.left;
if (q == NULL)
c308: 0a000081 beq c514 <rtems_bdbuf_get_buffer_from_lru_list+0x3b8>
{
q = node;
p->avl.left = q;
c30c: e1a03000 mov r3, r0 <== NOT EXECUTED
c310: e1a0c001 mov ip, r1 <== NOT EXECUTED
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
c314: e5930018 ldr r0, [r3, #24]
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
c318: e1a0100c mov r1, ip
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
c31c: e1550000 cmp r5, r0
return 0;
}
while (p != NULL)
{
*buf_prev++ = p;
c320: e4813004 str r3, [r1], #4
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
c324: e5939014 ldr r9, [r3, #20]
c328: 9affffee bls c2e8 <rtems_bdbuf_get_buffer_from_lru_list+0x18c>
{
p->avl.cache = 1;
q = p->avl.right;
c32c: e593000c ldr r0, [r3, #12]
if (q == NULL)
c330: e3500000 cmp r0, #0
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
{
p->avl.cache = 1;
c334: e5c36010 strb r6, [r3, #16]
q = p->avl.right;
if (q == NULL)
c338: 1afffff3 bne c30c <rtems_bdbuf_get_buffer_from_lru_list+0x1b0>
{
q = node;
p->avl.right = q = node;
c33c: e583200c str r2, [r3, #12]
}
p = q;
}
q->avl.left = q->avl.right = NULL;
c340: e3a05000 mov r5, #0
c344: e582500c str r5, [r2, #12]
c348: e5825008 str r5, [r2, #8]
q->avl.bal = 0;
c34c: e5c25011 strb r5, [r2, #17]
c350: e1d301d0 ldrsb r0, [r3, #16]
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
c354: e3a06001 mov r6, #1
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
c358: e3e08000 mvn r8, #0
c35c: ea000015 b c3b8 <rtems_bdbuf_get_buffer_from_lru_list+0x25c>
break;
}
}
else
{
switch (p->avl.bal)
c360: e1d311d1 ldrsb r1, [r3, #17]
c364: e3510000 cmp r1, #0
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = 1;
c368: 05c36011 strbeq r6, [r3, #17]
c36c: 01a01003 moveq r1, r3
c370: 03a04001 moveq r4, #1
break;
}
}
else
{
switch (p->avl.bal)
c374: 0a000005 beq c390 <rtems_bdbuf_get_buffer_from_lru_list+0x234>
c378: e3510001 cmp r1, #1 <== NOT EXECUTED
c37c: 0a000045 beq c498 <rtems_bdbuf_get_buffer_from_lru_list+0x33c><== NOT EXECUTED
c380: e3710001 cmn r1, #1 <== NOT EXECUTED
c384: 0a00003f beq c488 <rtems_bdbuf_get_buffer_from_lru_list+0x32c><== NOT EXECUTED
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
c388: e1a01003 mov r1, r3 <== NOT EXECUTED
c38c: e3a04001 mov r4, #1 <== NOT EXECUTED
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
c390: e157000c cmp r7, ip
c394: 2a00002d bcs c450 <rtems_bdbuf_get_buffer_from_lru_list+0x2f4>
{
p = *--buf_prev;
c398: e51c3004 ldr r3, [ip, #-4] <== NOT EXECUTED
if (p->avl.cache == -1)
c39c: e1d301d0 ldrsb r0, [r3, #16] <== NOT EXECUTED
c3a0: e3700001 cmn r0, #1 <== NOT EXECUTED
{
p->avl.left = q;
c3a4: 05831008 streq r1, [r3, #8] <== NOT EXECUTED
}
else
{
p->avl.right = q;
c3a8: 1583100c strne r1, [r3, #12] <== NOT EXECUTED
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
c3ac: e3540000 cmp r4, #0 <== NOT EXECUTED
p->avl.right = q;
}
}
else
{
*root = p;
c3b0: e24cc004 sub ip, ip, #4 <== NOT EXECUTED
q->avl.left = q->avl.right = NULL;
q->avl.bal = 0;
modified = true;
buf_prev--;
while (modified)
c3b4: 0a000027 beq c458 <rtems_bdbuf_get_buffer_from_lru_list+0x2fc><== NOT EXECUTED
{
if (p->avl.cache == -1)
c3b8: e3700001 cmn r0, #1
c3bc: 1affffe7 bne c360 <rtems_bdbuf_get_buffer_from_lru_list+0x204>
{
switch (p->avl.bal)
c3c0: e1d311d1 ldrsb r1, [r3, #17]
c3c4: e3510000 cmp r1, #0
p->avl.bal = 0;
modified = false;
break;
case 0:
p->avl.bal = -1;
c3c8: 05c30011 strbeq r0, [r3, #17]
c3cc: 01a01003 moveq r1, r3
c3d0: 03a04001 moveq r4, #1
while (modified)
{
if (p->avl.cache == -1)
{
switch (p->avl.bal)
c3d4: 0affffed beq c390 <rtems_bdbuf_get_buffer_from_lru_list+0x234>
c3d8: e3510001 cmp r1, #1 <== NOT EXECUTED
c3dc: 0a000029 beq c488 <rtems_bdbuf_get_buffer_from_lru_list+0x32c><== NOT EXECUTED
c3e0: e3710001 cmn r1, #1 <== NOT EXECUTED
c3e4: 1affffe7 bne c388 <rtems_bdbuf_get_buffer_from_lru_list+0x22c><== NOT EXECUTED
case 0:
p->avl.bal = -1;
break;
case -1:
p1 = p->avl.left;
c3e8: e5931008 ldr r1, [r3, #8] <== NOT EXECUTED
if (p1->avl.bal == -1) /* simple LL-turn */
c3ec: e1d101d1 ldrsb r0, [r1, #17] <== NOT EXECUTED
c3f0: e3700001 cmn r0, #1 <== NOT EXECUTED
c3f4: 0a000041 beq c500 <rtems_bdbuf_get_buffer_from_lru_list+0x3a4><== NOT EXECUTED
p->avl.bal = 0;
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
c3f8: e591000c ldr r0, [r1, #12] <== NOT EXECUTED
p1->avl.right = p2->avl.left;
c3fc: e5904008 ldr r4, [r0, #8] <== NOT EXECUTED
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
c400: e1d0a1d1 ldrsb sl, [r0, #17] <== NOT EXECUTED
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
c404: e581400c str r4, [r1, #12] <== NOT EXECUTED
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
c408: e37a0001 cmn sl, #1 <== NOT EXECUTED
c40c: 05c36011 strbeq r6, [r3, #17] <== NOT EXECUTED
c410: 15c35011 strbne r5, [r3, #17] <== NOT EXECUTED
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
c414: e590400c ldr r4, [r0, #12] <== NOT EXECUTED
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
c418: e5801008 str r1, [r0, #8] <== NOT EXECUTED
p->avl.left = p2->avl.right;
p2->avl.right = p;
c41c: e580300c str r3, [r0, #12] <== NOT EXECUTED
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
c420: e5834008 str r4, [r3, #8] <== NOT EXECUTED
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = +1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
c424: e1d031d1 ldrsb r3, [r0, #17] <== NOT EXECUTED
c428: e3530001 cmp r3, #1 <== NOT EXECUTED
c42c: 05c18011 strbeq r8, [r1, #17] <== NOT EXECUTED
c430: 01a01000 moveq r1, r0 <== NOT EXECUTED
c434: 0a000001 beq c440 <rtems_bdbuf_get_buffer_from_lru_list+0x2e4><== NOT EXECUTED
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
c438: e5c15011 strb r5, [r1, #17] <== NOT EXECUTED
c43c: e1a01000 mov r1, r0 <== NOT EXECUTED
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
c440: e157000c cmp r7, ip <== NOT EXECUTED
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
p = p2;
}
p->avl.bal = 0;
c444: e5c15011 strb r5, [r1, #17] <== NOT EXECUTED
c448: e3a04000 mov r4, #0 <== NOT EXECUTED
default:
break;
}
}
q = p;
if (buf_prev > buf_stack)
c44c: 3affffd1 bcc c398 <rtems_bdbuf_get_buffer_from_lru_list+0x23c><== NOT EXECUTED
p->avl.right = q;
}
}
else
{
*root = p;
c450: e59f00dc ldr r0, [pc, #220] ; c534 <rtems_bdbuf_get_buffer_from_lru_list+0x3d8>
c454: e5801040 str r1, [r0, #64] ; 0x40
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c458: e3a03001 mov r3, #1
c45c: e5823024 str r3, [r2, #36] ; 0x24
if (empty_bd != NULL)
{
rtems_bdbuf_setup_empty_buffer (empty_bd, dev, block);
return empty_bd;
c460: eaffff84 b c278 <rtems_bdbuf_get_buffer_from_lru_list+0x11c>
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
c464: e1550000 cmp r5, r0
c468: 1affffa3 bne c2fc <rtems_bdbuf_get_buffer_from_lru_list+0x1a0>
c46c: e593001c ldr r0, [r3, #28]
c470: e15a0000 cmp sl, r0
c474: 8affffac bhi c32c <rtems_bdbuf_get_buffer_from_lru_list+0x1d0>
q = node;
p->avl.right = q = node;
break;
}
}
else if ((p->dev != dev) || (p->block != block))
c478: 1affff9f bne c2fc <rtems_bdbuf_get_buffer_from_lru_list+0x1a0>
bd->avl.left = NULL;
bd->avl.right = NULL;
bd->waiters = 0;
if (rtems_bdbuf_avl_insert (&bdbuf_cache.tree, bd) != 0)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_RECYCLE);
c47c: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
c480: e280001b add r0, r0, #27 <== NOT EXECUTED
c484: ebffeb1b bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
else
{
switch (p->avl.bal)
{
case -1:
p->avl.bal = 0;
c488: e5c35011 strb r5, [r3, #17] <== NOT EXECUTED
c48c: e1a01003 mov r1, r3 <== NOT EXECUTED
c490: e3a04000 mov r4, #0 <== NOT EXECUTED
c494: eaffffbd b c390 <rtems_bdbuf_get_buffer_from_lru_list+0x234><== NOT EXECUTED
case 0:
p->avl.bal = 1;
break;
case 1:
p1 = p->avl.right;
c498: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
if (p1->avl.bal == 1) /* simple RR-turn */
c49c: e1d101d1 ldrsb r0, [r1, #17] <== NOT EXECUTED
c4a0: e3500001 cmp r0, #1 <== NOT EXECUTED
c4a4: 0a000010 beq c4ec <rtems_bdbuf_get_buffer_from_lru_list+0x390><== NOT EXECUTED
p->avl.bal = 0;
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
c4a8: e5910008 ldr r0, [r1, #8] <== NOT EXECUTED
p1->avl.left = p2->avl.right;
c4ac: e590400c ldr r4, [r0, #12] <== NOT EXECUTED
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
c4b0: e1d0a1d1 ldrsb sl, [r0, #17] <== NOT EXECUTED
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
c4b4: e5814008 str r4, [r1, #8] <== NOT EXECUTED
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
c4b8: e35a0001 cmp sl, #1 <== NOT EXECUTED
c4bc: 05c38011 strbeq r8, [r3, #17] <== NOT EXECUTED
c4c0: 15c35011 strbne r5, [r3, #17] <== NOT EXECUTED
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
c4c4: e5904008 ldr r4, [r0, #8] <== NOT EXECUTED
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
c4c8: e580100c str r1, [r0, #12] <== NOT EXECUTED
p->avl.right = p2->avl.left;
p2->avl.left = p;
c4cc: e5803008 str r3, [r0, #8] <== NOT EXECUTED
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
c4d0: e583400c str r4, [r3, #12] <== NOT EXECUTED
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = +1; else p1->avl.bal = 0;
c4d4: e1d031d1 ldrsb r3, [r0, #17] <== NOT EXECUTED
c4d8: e3730001 cmn r3, #1 <== NOT EXECUTED
c4dc: 05c16011 strbeq r6, [r1, #17] <== NOT EXECUTED
c4e0: 01a01000 moveq r1, r0 <== NOT EXECUTED
c4e4: 1affffd3 bne c438 <rtems_bdbuf_get_buffer_from_lru_list+0x2dc><== NOT EXECUTED
c4e8: eaffffd4 b c440 <rtems_bdbuf_get_buffer_from_lru_list+0x2e4><== NOT EXECUTED
case 1:
p1 = p->avl.right;
if (p1->avl.bal == 1) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
c4ec: e5910008 ldr r0, [r1, #8] <== NOT EXECUTED
p1->avl.left = p;
p->avl.bal = 0;
c4f0: e5c35011 strb r5, [r3, #17] <== NOT EXECUTED
case 1:
p1 = p->avl.right;
if (p1->avl.bal == 1) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
c4f4: e583000c str r0, [r3, #12] <== NOT EXECUTED
p1->avl.left = p;
c4f8: e5813008 str r3, [r1, #8] <== NOT EXECUTED
c4fc: eaffffcf b c440 <rtems_bdbuf_get_buffer_from_lru_list+0x2e4><== NOT EXECUTED
case -1:
p1 = p->avl.left;
if (p1->avl.bal == -1) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
c500: e591000c ldr r0, [r1, #12] <== NOT EXECUTED
p1->avl.right = p;
p->avl.bal = 0;
c504: e5c35011 strb r5, [r3, #17] <== NOT EXECUTED
case -1:
p1 = p->avl.left;
if (p1->avl.bal == -1) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
c508: e5830008 str r0, [r3, #8] <== NOT EXECUTED
p1->avl.right = p;
c50c: e581300c str r3, [r1, #12] <== NOT EXECUTED
c510: eaffffca b c440 <rtems_bdbuf_get_buffer_from_lru_list+0x2e4><== NOT EXECUTED
p->avl.cache = -1;
q = p->avl.left;
if (q == NULL)
{
q = node;
p->avl.left = q;
c514: e5832008 str r2, [r3, #8]
c518: eaffff88 b c340 <rtems_bdbuf_get_buffer_from_lru_list+0x1e4>
bool modified = false;
if (p == NULL)
{
*root = node;
c51c: e59f1010 ldr r1, [pc, #16] ; c534 <rtems_bdbuf_get_buffer_from_lru_list+0x3d8>
c520: e5812040 str r2, [r1, #64] ; 0x40
node->avl.left = NULL;
node->avl.right = NULL;
node->avl.bal = 0;
c524: e5c23011 strb r3, [r2, #17]
bool modified = false;
if (p == NULL)
{
*root = node;
node->avl.left = NULL;
c528: e5823008 str r3, [r2, #8]
node->avl.right = NULL;
c52c: e582300c str r3, [r2, #12]
c530: eaffffc8 b c458 <rtems_bdbuf_get_buffer_from_lru_list+0x2fc>
0000ad44 <rtems_bdbuf_init>:
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
ad44: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_mode prev_mode;
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
ad48: e59f339c ldr r3, [pc, #924] ; b0ec <rtems_bdbuf_init+0x3a8>
ad4c: e5933000 ldr r3, [r3]
ad50: e3530000 cmp r3, #0
*
* @return rtems_status_code The initialisation status.
*/
rtems_status_code
rtems_bdbuf_init (void)
{
ad54: e24dd008 sub sp, sp, #8
rtems_mode prev_mode;
if (rtems_bdbuf_tracer)
printf ("bdbuf:init\n");
if (rtems_interrupt_is_in_progress())
ad58: 13a00012 movne r0, #18
ad5c: 1a000008 bne ad84 <rtems_bdbuf_init+0x40>
return RTEMS_CALLED_FROM_ISR;
/*
* Check the configuration table values.
*/
if ((bdbuf_config.buffer_max % bdbuf_config.buffer_min) != 0)
ad60: e59f5388 ldr r5, [pc, #904] ; b0f0 <rtems_bdbuf_init+0x3ac>
ad64: e2856020 add r6, r5, #32
ad68: e8960140 ldm r6, {r6, r8}
ad6c: e1a00008 mov r0, r8
ad70: e1a01006 mov r1, r6
ad74: eb004280 bl 1b77c <__umodsi3>
ad78: e3500000 cmp r0, #0
ad7c: 13a0000a movne r0, #10
ad80: 0a000001 beq ad8c <rtems_bdbuf_init+0x48>
}
bdbuf_cache.initialised = false;
return RTEMS_UNSATISFIED;
}
ad84: e28dd008 add sp, sp, #8
ad88: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/* * We use a special variable to manage the initialisation incase we have * completing threads doing this. You may get errors if the another thread * makes a call and we have not finished initialisation. */ prev_mode = rtems_bdbuf_disable_preemption ();
ad8c: ebffff9c bl ac04 <rtems_bdbuf_disable_preemption>
if (bdbuf_cache.initialised)
ad90: e59f435c ldr r4, [pc, #860] ; b0f4 <rtems_bdbuf_init+0x3b0>
ad94: e5d47088 ldrb r7, [r4, #136] ; 0x88
ad98: e3570000 cmp r7, #0
/* * We use a special variable to manage the initialisation incase we have * completing threads doing this. You may get errors if the another thread * makes a call and we have not finished initialisation. */ prev_mode = rtems_bdbuf_disable_preemption ();
ad9c: e1a0a000 mov sl, r0
if (bdbuf_cache.initialised)
ada0: 0a000002 beq adb0 <rtems_bdbuf_init+0x6c>
{
rtems_bdbuf_restore_preemption (prev_mode);
ada4: ebffffa7 bl ac48 <rtems_bdbuf_restore_preemption> <== NOT EXECUTED
ada8: e3a0000c mov r0, #12 <== NOT EXECUTED
return RTEMS_RESOURCE_IN_USE;
adac: eafffff4 b ad84 <rtems_bdbuf_init+0x40> <== NOT EXECUTED
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
adb0: e1a01007 mov r1, r7
adb4: e3a0208c mov r2, #140 ; 0x8c
adb8: e1a00004 mov r0, r4
adbc: eb001f54 bl 12b14 <memset>
bdbuf_cache.initialised = true; rtems_bdbuf_restore_preemption (prev_mode);
adc0: e1a0000a mov r0, sl
rtems_bdbuf_restore_preemption (prev_mode);
return RTEMS_RESOURCE_IN_USE;
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
bdbuf_cache.initialised = true;
adc4: e3a0a001 mov sl, #1
*/
cache_aligment = 32; /* FIXME rtems_cache_get_data_line_size() */
if (cache_aligment <= 0)
cache_aligment = CPU_ALIGNMENT;
bdbuf_cache.sync_device = BDBUF_INVALID_DEV;
adc8: e3e0b000 mvn fp, #0
rtems_bdbuf_restore_preemption (prev_mode);
return RTEMS_RESOURCE_IN_USE;
}
memset(&bdbuf_cache, 0, sizeof(bdbuf_cache));
bdbuf_cache.initialised = true;
adcc: e5c4a088 strb sl, [r4, #136] ; 0x88
rtems_bdbuf_restore_preemption (prev_mode);
add0: ebffff9c bl ac48 <rtems_bdbuf_restore_preemption>
*/
cache_aligment = 32; /* FIXME rtems_cache_get_data_line_size() */
if (cache_aligment <= 0)
cache_aligment = CPU_ALIGNMENT;
bdbuf_cache.sync_device = BDBUF_INVALID_DEV;
add4: e3e0c000 mvn ip, #0
add8: e584b038 str fp, [r4, #56] ; 0x38
addc: e584c03c str ip, [r4, #60] ; 0x3c
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
ade0: e59fc310 ldr ip, [pc, #784] ; b0f8 <rtems_bdbuf_init+0x3b4>
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
ade4: e59fb310 ldr fp, [pc, #784] ; b0fc <rtems_bdbuf_init+0x3b8>
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
ade8: e584c008 str ip, [r4, #8]
adec: e59fc30c ldr ip, [pc, #780] ; b100 <rtems_bdbuf_init+0x3bc>
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
adf0: e584b04c str fp, [r4, #76] ; 0x4c
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
adf4: e584c050 str ip, [r4, #80] ; 0x50
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
adf8: e59fb304 ldr fp, [pc, #772] ; b104 <rtems_bdbuf_init+0x3c0>
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
adfc: e59fc304 ldr ip, [pc, #772] ; b108 <rtems_bdbuf_init+0x3c4>
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
ae00: e584b058 str fp, [r4, #88] ; 0x58
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
ae04: e584c05c str ip, [r4, #92] ; 0x5c
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
ae08: e59fb2fc ldr fp, [pc, #764] ; b10c <rtems_bdbuf_init+0x3c8>
rtems_chain_initialize_empty (&bdbuf_cache.sync);
/*
* Create the locks for the cache.
*/
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'l'),
ae0c: e59fc2fc ldr ip, [pc, #764] ; b110 <rtems_bdbuf_init+0x3cc>
ae10: e1a03007 mov r3, r7
ae14: e284e008 add lr, r4, #8
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
ae18: e2849048 add r9, r4, #72 ; 0x48
ae1c: e59f02f0 ldr r0, [pc, #752] ; b114 <rtems_bdbuf_init+0x3d0>
ae20: e1a0100a mov r1, sl
ae24: e3a02054 mov r2, #84 ; 0x54
the_chain->permanent_null = NULL;
ae28: e584700c str r7, [r4, #12]
ae2c: e5847048 str r7, [r4, #72] ; 0x48
ae30: e5847054 str r7, [r4, #84] ; 0x54
ae34: e5847060 str r7, [r4, #96] ; 0x60
the_chain->last = _Chain_Head(the_chain);
ae38: e584e010 str lr, [r4, #16]
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
ae3c: e5849044 str r9, [r4, #68] ; 0x44
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
ae40: e584b064 str fp, [r4, #100] ; 0x64
ae44: e58dc000 str ip, [sp]
ae48: ebffee97 bl 68ac <rtems_semaphore_create>
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
ae4c: e2507000 subs r7, r0, #0
ae50: 0a00001e beq aed0 <rtems_bdbuf_init+0x18c>
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.swapout != 0)
ae54: e5940000 ldr r0, [r4] <== NOT EXECUTED
ae58: e3500000 cmp r0, #0 <== NOT EXECUTED
ae5c: 1a000014 bne aeb4 <rtems_bdbuf_init+0x170> <== NOT EXECUTED
rtems_task_delete (bdbuf_cache.swapout);
free (bdbuf_cache.buffers);
ae60: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
ae64: ebffe0a5 bl 3100 <free> <== NOT EXECUTED
free (bdbuf_cache.groups);
ae68: e5940084 ldr r0, [r4, #132] ; 0x84 <== NOT EXECUTED
ae6c: ebffe0a3 bl 3100 <free> <== NOT EXECUTED
free (bdbuf_cache.bds);
ae70: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED
ae74: ebffe0a1 bl 3100 <free> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.buffer_waiters.sema);
ae78: e594007c ldr r0, [r4, #124] ; 0x7c <== NOT EXECUTED
ae7c: ebffeefc bl 6a74 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.access_waiters.sema);
ae80: e594006c ldr r0, [r4, #108] ; 0x6c <== NOT EXECUTED
ae84: ebffeefa bl 6a74 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
ae88: e5940074 ldr r0, [r4, #116] ; 0x74 <== NOT EXECUTED
ae8c: ebffeef8 bl 6a74 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.sync_lock);
ae90: e594002c ldr r0, [r4, #44] ; 0x2c <== NOT EXECUTED
ae94: ebffeef6 bl 6a74 <rtems_semaphore_delete> <== NOT EXECUTED
if (bdbuf_cache.lock != 0)
ae98: e5943028 ldr r3, [r4, #40] ; 0x28 <== NOT EXECUTED
ae9c: e3530000 cmp r3, #0 <== NOT EXECUTED
aea0: 1a000005 bne aebc <rtems_bdbuf_init+0x178> <== NOT EXECUTED
{
rtems_bdbuf_unlock_cache ();
rtems_semaphore_delete (bdbuf_cache.lock);
}
bdbuf_cache.initialised = false;
aea4: e3a03000 mov r3, #0 <== NOT EXECUTED
aea8: e5c43088 strb r3, [r4, #136] ; 0x88 <== NOT EXECUTED
aeac: e3a0000d mov r0, #13 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
aeb0: eaffffb3 b ad84 <rtems_bdbuf_init+0x40> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
error:
if (bdbuf_cache.swapout != 0)
rtems_task_delete (bdbuf_cache.swapout);
aeb4: ebffefd7 bl 6e18 <rtems_task_delete> <== NOT EXECUTED
aeb8: eaffffe8 b ae60 <rtems_bdbuf_init+0x11c> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.transfer_waiters.sema);
rtems_semaphore_delete (bdbuf_cache.sync_lock);
if (bdbuf_cache.lock != 0)
{
rtems_bdbuf_unlock_cache ();
aebc: ebfffe7e bl a8bc <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
rtems_semaphore_delete (bdbuf_cache.lock);
aec0: e59f322c ldr r3, [pc, #556] ; b0f4 <rtems_bdbuf_init+0x3b0><== NOT EXECUTED
aec4: e5930028 ldr r0, [r3, #40] ; 0x28 <== NOT EXECUTED
aec8: ebffeee9 bl 6a74 <rtems_semaphore_delete> <== NOT EXECUTED
aecc: eafffff4 b aea4 <rtems_bdbuf_init+0x160> <== NOT EXECUTED
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.lock);
if (sc != RTEMS_SUCCESSFUL)
goto error;
rtems_bdbuf_lock_cache ();
aed0: ebfffdfe bl a6d0 <rtems_bdbuf_lock_cache>
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 's'),
aed4: e1a0100a mov r1, sl
aed8: e284c02c add ip, r4, #44 ; 0x2c
aedc: e1a03007 mov r3, r7
aee0: e59f0230 ldr r0, [pc, #560] ; b118 <rtems_bdbuf_init+0x3d4>
aee4: e3a02054 mov r2, #84 ; 0x54
aee8: e58dc000 str ip, [sp]
aeec: ebffee6e bl 68ac <rtems_semaphore_create>
1, RTEMS_BDBUF_CACHE_LOCK_ATTRIBS, 0,
&bdbuf_cache.sync_lock);
if (sc != RTEMS_SUCCESSFUL)
aef0: e2501000 subs r1, r0, #0
aef4: 1affffd6 bne ae54 <rtems_bdbuf_init+0x110>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'a'),
aef8: e284c06c add ip, r4, #108 ; 0x6c
aefc: e1a03001 mov r3, r1
af00: e59f0214 ldr r0, [pc, #532] ; b11c <rtems_bdbuf_init+0x3d8>
af04: e3a02024 mov r2, #36 ; 0x24
af08: e58dc000 str ip, [sp]
af0c: ebffee66 bl 68ac <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.access_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
af10: e2501000 subs r1, r0, #0
af14: 1affffce bne ae54 <rtems_bdbuf_init+0x110>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 't'),
af18: e284c074 add ip, r4, #116 ; 0x74
af1c: e1a03001 mov r3, r1
af20: e59f01f8 ldr r0, [pc, #504] ; b120 <rtems_bdbuf_init+0x3dc>
af24: e3a02024 mov r2, #36 ; 0x24
af28: e58dc000 str ip, [sp]
af2c: ebffee5e bl 68ac <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.transfer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
af30: e2501000 subs r1, r0, #0
af34: 1affffc6 bne ae54 <rtems_bdbuf_init+0x110>
goto error;
sc = rtems_semaphore_create (rtems_build_name ('B', 'D', 'C', 'b'),
af38: e284c07c add ip, r4, #124 ; 0x7c
af3c: e59f01e0 ldr r0, [pc, #480] ; b124 <rtems_bdbuf_init+0x3e0>
af40: e3a02024 mov r2, #36 ; 0x24
af44: e1a03001 mov r3, r1
af48: e58dc000 str ip, [sp]
af4c: ebffee56 bl 68ac <rtems_semaphore_create>
0, RTEMS_BDBUF_CACHE_WAITER_ATTRIBS, 0,
&bdbuf_cache.buffer_waiters.sema);
if (sc != RTEMS_SUCCESSFUL)
af50: e3500000 cmp r0, #0
af54: 1affffbe bne ae54 <rtems_bdbuf_init+0x110>
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
af58: e595001c ldr r0, [r5, #28]
af5c: e1a01006 mov r1, r6
af60: eb0041c1 bl 1b66c <__aeabi_uidiv>
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
af64: e1a01006 mov r1, r6
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
af68: e1a07000 mov r7, r0
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
af6c: e1a00008 mov r0, r8
goto error;
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
af70: e584701c str r7, [r4, #28]
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
af74: eb0041bc bl 1b66c <__aeabi_uidiv>
af78: e1a03000 mov r3, r0
bdbuf_cache.group_count =
af7c: e1a01000 mov r1, r0
af80: e1a00007 mov r0, r7
/*
* Compute the various number of elements in the cache.
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
af84: e5843020 str r3, [r4, #32]
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
af88: eb0041b7 bl 1b66c <__aeabi_uidiv>
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
af8c: e1a01007 mov r1, r7
*/
bdbuf_cache.buffer_min_count =
bdbuf_config.size / bdbuf_config.buffer_min;
bdbuf_cache.max_bds_per_group =
bdbuf_config.buffer_max / bdbuf_config.buffer_min;
bdbuf_cache.group_count =
af90: e5840080 str r0, [r4, #128] ; 0x80
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
af94: e3a0003c mov r0, #60 ; 0x3c
af98: ebffdfc2 bl 2ea8 <calloc>
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
af9c: e3500000 cmp r0, #0
bdbuf_cache.buffer_min_count / bdbuf_cache.max_bds_per_group;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.bds = calloc (sizeof (rtems_bdbuf_buffer),
afa0: e5840014 str r0, [r4, #20]
bdbuf_cache.buffer_min_count);
if (!bdbuf_cache.bds)
afa4: 0affffaa beq ae54 <rtems_bdbuf_init+0x110>
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
afa8: e3a00014 mov r0, #20
afac: e5941080 ldr r1, [r4, #128] ; 0x80
afb0: ebffdfbc bl 2ea8 <calloc>
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
afb4: e3500000 cmp r0, #0
goto error;
/*
* Allocate the memory for the buffer descriptors.
*/
bdbuf_cache.groups = calloc (sizeof (rtems_bdbuf_group),
afb8: e5840084 str r0, [r4, #132] ; 0x84
bdbuf_cache.group_count);
if (!bdbuf_cache.groups)
afbc: 0affffa4 beq ae54 <rtems_bdbuf_init+0x110>
* aligned. It is possible to free the memory allocated by rtems_memalign()
* with free(). Return 0 if allocated.
*
* The memory allocate allows a
*/
if (rtems_memalign ((void **) &bdbuf_cache.buffers,
afc0: e594201c ldr r2, [r4, #28]
afc4: e59f7128 ldr r7, [pc, #296] ; b0f4 <rtems_bdbuf_init+0x3b0>
afc8: e0020296 mul r2, r6, r2
afcc: e2870018 add r0, r7, #24
afd0: e3a01020 mov r1, #32
afd4: eb001078 bl f1bc <rtems_memalign>
afd8: e3500000 cmp r0, #0
afdc: 1affff9c bne ae54 <rtems_bdbuf_init+0x110>
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
afe0: e5979084 ldr r9, [r7, #132] ; 0x84
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
afe4: e5978014 ldr r8, [r7, #20]
afe8: e5977018 ldr r7, [r7, #24]
afec: e1a0a000 mov sl, r0
/*
* The cache is empty after opening so we need to add all the buffers to it
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
aff0: e594301c ldr r3, [r4, #28]
aff4: e15a0003 cmp sl, r3
aff8: e59f30f4 ldr r3, [pc, #244] ; b0f4 <rtems_bdbuf_init+0x3b0>
affc: e1a01008 mov r1, r8
b000: e2830044 add r0, r3, #68 ; 0x44
b004: 2a000012 bcs b054 <rtems_bdbuf_init+0x310>
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
{
bd->dev = BDBUF_INVALID_DEV;
b008: e3e02000 mvn r2, #0
b00c: e3e03000 mvn r3, #0
b010: e5882014 str r2, [r8, #20]
b014: e5883018 str r3, [r8, #24]
bd->group = group;
b018: e588902c str r9, [r8, #44] ; 0x2c
bd->buffer = buffer;
b01c: e5887020 str r7, [r8, #32]
b020: ebfff160 bl 75a8 <_Chain_Append>
rtems_chain_append (&bdbuf_cache.lru, &bd->link);
if ((b % bdbuf_cache.max_bds_per_group) ==
b024: e59f30c8 ldr r3, [pc, #200] ; b0f4 <rtems_bdbuf_init+0x3b0>
b028: e593b020 ldr fp, [r3, #32]
b02c: e1a0000a mov r0, sl
b030: e1a0100b mov r1, fp
b034: eb0041d0 bl 1b77c <__umodsi3>
b038: e24bb001 sub fp, fp, #1
b03c: e150000b cmp r0, fp
(bdbuf_cache.max_bds_per_group - 1))
group++;
b040: 02899014 addeq r9, r9, #20
* and initialise the groups.
*/
for (b = 0, group = bdbuf_cache.groups,
bd = bdbuf_cache.bds, buffer = bdbuf_cache.buffers;
b < bdbuf_cache.buffer_min_count;
b++, bd++, buffer += bdbuf_config.buffer_min)
b044: e28aa001 add sl, sl, #1
b048: e288803c add r8, r8, #60 ; 0x3c
b04c: e0877006 add r7, r7, r6
b050: eaffffe6 b aff0 <rtems_bdbuf_init+0x2ac>
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
b054: e5930020 ldr r0, [r3, #32]
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
b058: e3a0203c mov r2, #60 ; 0x3c
b05c: e00e0092 mul lr, r2, r0
group++;
}
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b060: e5931014 ldr r1, [r3, #20]
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
group = bdbuf_cache.groups,
b064: e5932084 ldr r2, [r3, #132] ; 0x84
bd = bdbuf_cache.bds;
b068: e593c080 ldr ip, [r3, #128] ; 0x80
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
b06c: e3a03000 mov r3, #0
if ((b % bdbuf_cache.max_bds_per_group) ==
(bdbuf_cache.max_bds_per_group - 1))
group++;
}
for (b = 0,
b070: e153000c cmp r3, ip
b074: 2a000005 bcs b090 <rtems_bdbuf_init+0x34c>
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
group->bdbuf = bd;
b078: e5821010 str r1, [r2, #16]
b < bdbuf_cache.group_count;
b++,
group++,
bd += bdbuf_cache.max_bds_per_group)
{
group->bds_per_group = bdbuf_cache.max_bds_per_group;
b07c: e5820008 str r0, [r2, #8]
for (b = 0,
group = bdbuf_cache.groups,
bd = bdbuf_cache.bds;
b < bdbuf_cache.group_count;
b++,
b080: e2833001 add r3, r3, #1
group++,
b084: e2822014 add r2, r2, #20
bd += bdbuf_cache.max_bds_per_group)
b088: e081100e add r1, r1, lr
b08c: eafffff7 b b070 <rtems_bdbuf_init+0x32c>
* threads.
*/
bdbuf_cache.swapout_enabled = true;
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
bdbuf_config.swapout_priority ?
b090: e5951008 ldr r1, [r5, #8]
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
b094: e3a0c001 mov ip, #1
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
b098: e3510000 cmp r1, #0
b09c: 03a0100f moveq r1, #15
/*
* Create and start swapout task. This task will create and manage the worker
* threads.
*/
bdbuf_cache.swapout_enabled = true;
b0a0: e5c4c004 strb ip, [r4, #4]
sc = rtems_task_create (rtems_build_name('B', 'S', 'W', 'P'),
b0a4: e59f007c ldr r0, [pc, #124] ; b128 <rtems_bdbuf_init+0x3e4>
b0a8: e3a0c000 mov ip, #0
b0ac: e3a02a02 mov r2, #8192 ; 0x2000
b0b0: e3a03b01 mov r3, #1024 ; 0x400
b0b4: e58dc000 str ip, [sp]
b0b8: e58d4004 str r4, [sp, #4]
b0bc: ebffef07 bl 6ce0 <rtems_task_create>
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT,
SWAPOUT_TASK_STACK_SIZE,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&bdbuf_cache.swapout);
if (sc != RTEMS_SUCCESSFUL)
b0c0: e3500000 cmp r0, #0
b0c4: 1affff62 bne ae54 <rtems_bdbuf_init+0x110>
goto error;
sc = rtems_task_start (bdbuf_cache.swapout,
b0c8: e5940000 ldr r0, [r4]
b0cc: e59f1058 ldr r1, [pc, #88] ; b12c <rtems_bdbuf_init+0x3e8>
b0d0: e1a02004 mov r2, r4
b0d4: ebffef93 bl 6f28 <rtems_task_start>
rtems_bdbuf_swapout_task,
(rtems_task_argument) &bdbuf_cache);
if (sc != RTEMS_SUCCESSFUL)
b0d8: e2505000 subs r5, r0, #0
b0dc: 1affff5c bne ae54 <rtems_bdbuf_init+0x110>
goto error;
rtems_bdbuf_unlock_cache ();
b0e0: ebfffdf5 bl a8bc <rtems_bdbuf_unlock_cache>
b0e4: e1a00005 mov r0, r5
return RTEMS_SUCCESSFUL;
b0e8: eaffff25 b ad84 <rtems_bdbuf_init+0x40>
0000a6ac <rtems_bdbuf_lock>:
* @param lock The mutex to lock.
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_lock (rtems_id lock, uint32_t fatal_error_code)
{
a6ac: e92d4010 push {r4, lr}
a6b0: e1a04001 mov r4, r1
rtems_status_code sc = rtems_semaphore_obtain (lock,
a6b4: e3a01000 mov r1, #0
a6b8: e1a02001 mov r2, r1
a6bc: ebfff115 bl 6b18 <rtems_semaphore_obtain>
RTEMS_WAIT,
RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
a6c0: e3500000 cmp r0, #0
a6c4: 08bd8010 popeq {r4, pc}
rtems_fatal_error_occurred (fatal_error_code);
a6c8: e1a00004 mov r0, r4 <== NOT EXECUTED
a6cc: ebfff289 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000a90c <rtems_bdbuf_obtain_disk>:
rtems_bdbuf_obtain_disk (dev_t dev,
rtems_blkdev_bnum block,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
a90c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
a910: e59f50e4 ldr r5, [pc, #228] ; a9fc <rtems_bdbuf_obtain_disk+0xf0>
a914: e5d5c088 ldrb ip, [r5, #136] ; 0x88
a918: e35c0000 cmp ip, #0
rtems_bdbuf_obtain_disk (dev_t dev,
rtems_blkdev_bnum block,
rtems_disk_device **dd_ptr,
rtems_blkdev_bnum *media_block_ptr,
size_t *bds_per_group_ptr)
{
a91c: e1a08002 mov r8, r2
a920: e1a0a003 mov sl, r3
a924: e28d601c add r6, sp, #28
a928: e89600c0 ldm r6, {r6, r7}
rtems_disk_device *dd = NULL;
if (!bdbuf_cache.initialised)
a92c: 03a00016 moveq r0, #22
a930: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return RTEMS_NOT_CONFIGURED;
/*
* Do not hold the cache lock when obtaining the disk table.
*/
dd = rtems_disk_obtain (dev);
a934: ebffddd5 bl 2090 <rtems_disk_obtain>
if (dd == NULL)
a938: e2504000 subs r4, r0, #0
a93c: 03a00004 moveq r0, #4
a940: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
return RTEMS_INVALID_ID;
*dd_ptr = dd;
if (media_block_ptr != NULL)
a944: e3560000 cmp r6, #0
*/
dd = rtems_disk_obtain (dev);
if (dd == NULL)
return RTEMS_INVALID_ID;
*dd_ptr = dd;
a948: e58a4000 str r4, [sl]
if (media_block_ptr != NULL)
a94c: 0a00000c beq a984 <rtems_bdbuf_obtain_disk+0x78>
static rtems_blkdev_bnum
rtems_bdbuf_media_block (rtems_blkdev_bnum block,
size_t block_size,
size_t media_block_size)
{
return (rtems_blkdev_bnum)
a950: e5940020 ldr r0, [r4, #32]
a954: e0832098 umull r2, r3, r8, r0
a958: e1a00002 mov r0, r2
a95c: e1a01003 mov r1, r3
a960: e5942024 ldr r2, [r4, #36] ; 0x24
a964: e3a03000 mov r3, #0
a968: eb00489c bl 1cbe0 <__udivdi3>
* the user.
*/
rtems_blkdev_bnum mb = rtems_bdbuf_media_block (block,
dd->block_size,
dd->media_block_size);
if (mb >= dd->size)
a96c: e594301c ldr r3, [r4, #28]
a970: e1530000 cmp r3, r0
a974: 9a00001c bls a9ec <rtems_bdbuf_obtain_disk+0xe0>
{
rtems_disk_release(dd);
return RTEMS_INVALID_NUMBER;
}
*media_block_ptr = mb + dd->start;
a978: e5943018 ldr r3, [r4, #24]
a97c: e0800003 add r0, r0, r3
a980: e5860000 str r0, [r6]
}
if (bds_per_group_ptr != NULL)
a984: e3570000 cmp r7, #0
a988: 01a00007 moveq r0, r7
a98c: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc}
rtems_bdbuf_bds_per_group (size_t size)
{
size_t bufs_per_size;
size_t bds_per_size;
if (size > bdbuf_config.buffer_max)
a990: e59f3068 ldr r3, [pc, #104] ; aa00 <rtems_bdbuf_obtain_disk+0xf4>
*media_block_ptr = mb + dd->start;
}
if (bds_per_group_ptr != NULL)
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
a994: e5940020 ldr r0, [r4, #32]
rtems_bdbuf_bds_per_group (size_t size)
{
size_t bufs_per_size;
size_t bds_per_size;
if (size > bdbuf_config.buffer_max)
a998: e5932024 ldr r2, [r3, #36] ; 0x24
a99c: e1500002 cmp r0, r2
a9a0: 8a000011 bhi a9ec <rtems_bdbuf_obtain_disk+0xe0>
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
a9a4: e5931020 ldr r1, [r3, #32]
a9a8: e2400001 sub r0, r0, #1
a9ac: eb00432e bl 1b66c <__aeabi_uidiv>
a9b0: e2800001 add r0, r0, #1
for (bds_per_size = 1;
a9b4: e3500001 cmp r0, #1
a9b8: 93a01001 movls r1, #1
a9bc: 9a000003 bls a9d0 <rtems_bdbuf_obtain_disk+0xc4>
a9c0: e3a01001 mov r1, #1
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
a9c4: e1a01081 lsl r1, r1, #1
if (size > bdbuf_config.buffer_max)
return 0;
bufs_per_size = ((size - 1) / bdbuf_config.buffer_min) + 1;
for (bds_per_size = 1;
a9c8: e1500001 cmp r0, r1
a9cc: 8afffffc bhi a9c4 <rtems_bdbuf_obtain_disk+0xb8>
bds_per_size < bufs_per_size;
bds_per_size <<= 1)
;
return bdbuf_cache.max_bds_per_group / bds_per_size;
a9d0: e5950020 ldr r0, [r5, #32]
a9d4: eb004324 bl 1b66c <__aeabi_uidiv>
if (bds_per_group_ptr != NULL)
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
if (bds_per_group == 0)
a9d8: e3500000 cmp r0, #0
a9dc: 0a000002 beq a9ec <rtems_bdbuf_obtain_disk+0xe0>
{
rtems_disk_release (dd);
return RTEMS_INVALID_NUMBER;
}
*bds_per_group_ptr = bds_per_group;
a9e0: e5870000 str r0, [r7]
a9e4: e3a00000 mov r0, #0
}
return RTEMS_SUCCESSFUL;
}
a9e8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
{
size_t bds_per_group = rtems_bdbuf_bds_per_group (dd->block_size);
if (bds_per_group == 0)
{
rtems_disk_release (dd);
a9ec: e1a00004 mov r0, r4 <== NOT EXECUTED
a9f0: ebffde3a bl 22e0 <rtems_disk_release> <== NOT EXECUTED
a9f4: e3a0000a mov r0, #10 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
a9f8: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
0000b6fc <rtems_bdbuf_purge>:
}
}
static void
rtems_bdbuf_purge (rtems_bdbuf_purge_compare compare, dev_t dev)
{
b6fc: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
b700: e24dd08c sub sp, sp, #140 ; 0x8c
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
b704: e28d7080 add r7, sp, #128 ; 0x80
the_chain->permanent_null = NULL;
b708: e3a05000 mov r5, #0
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
b70c: e2873004 add r3, r7, #4
b710: e58d3080 str r3, [sp, #128] ; 0x80
b714: e1a06000 mov r6, r0
the_chain->permanent_null = NULL;
b718: e58d5084 str r5, [sp, #132] ; 0x84
the_chain->last = _Chain_Head(the_chain);
b71c: e58d7088 str r7, [sp, #136] ; 0x88
b720: e1a08001 mov r8, r1
b724: e1a09002 mov r9, r2
rtems_chain_control purge_list;
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
b728: ebfffbe8 bl a6d0 <rtems_bdbuf_lock_cache>
rtems_bdbuf_purge_compare compare,
dev_t dev)
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
b72c: e59f3180 ldr r3, [pc, #384] ; b8b4 <rtems_bdbuf_purge+0x1b8>
b730: e5934040 ldr r4, [r3, #64] ; 0x40
*prev = NULL;
while (cur != NULL)
b734: e1540005 cmp r4, r5
{
rtems_bdbuf_buffer *stack [RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
b738: e58d5000 str r5, [sp]
while (cur != NULL)
b73c: 0a000038 beq b824 <rtems_bdbuf_purge+0x128>
b740: e1a0500d mov r5, sp
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
b744: e3a0a006 mov sl, #6
b748: e3a0b00a mov fp, #10
*prev = NULL;
while (cur != NULL)
{
if ((*compare) (cur->dev, dev))
b74c: e2841014 add r1, r4, #20
b750: e8910003 ldm r1, {r0, r1}
b754: e1a02008 mov r2, r8
b758: e1a03009 mov r3, r9
b75c: e1a0e00f mov lr, pc
b760: e12fff16 bx r6
b764: e3500000 cmp r0, #0
b768: 0a00000f beq b7ac <rtems_bdbuf_purge+0xb0>
{
switch (cur->state)
b76c: e5943024 ldr r3, [r4, #36] ; 0x24
b770: e353000a cmp r3, #10
b774: 979ff103 ldrls pc, [pc, r3, lsl #2]
b778: ea00003b b b86c <rtems_bdbuf_purge+0x170> <== NOT EXECUTED
b77c: 0000b7ac .word 0x0000b7ac <== NOT EXECUTED
b780: 0000b7ac .word 0x0000b7ac <== NOT EXECUTED
b784: 0000b7e8 .word 0x0000b7e8 <== NOT EXECUTED
b788: 0000b864 .word 0x0000b864 <== NOT EXECUTED
b78c: 0000b864 .word 0x0000b864 <== NOT EXECUTED
b790: 0000b864 .word 0x0000b864 <== NOT EXECUTED
b794: 0000b7ac .word 0x0000b7ac <== NOT EXECUTED
b798: 0000b7d8 .word 0x0000b7d8 <== NOT EXECUTED
b79c: 0000b7d0 .word 0x0000b7d0 <== NOT EXECUTED
b7a0: 0000b7a8 .word 0x0000b7a8 <== NOT EXECUTED
b7a4: 0000b7ac .word 0x0000b7ac <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
b7a8: e584b024 str fp, [r4, #36] ; 0x24
default:
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_STATE_11);
}
}
if (cur->avl.left != NULL)
b7ac: e5943008 ldr r3, [r4, #8]
b7b0: e3530000 cmp r3, #0
b7b4: 0a000013 beq b808 <rtems_bdbuf_purge+0x10c>
{
/* Left */
++prev;
*prev = cur;
b7b8: e5a54004 str r4, [r5, #4]! <== NOT EXECUTED
cur = cur->avl.left;
b7bc: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
b7c0: e3530000 cmp r3, #0 <== NOT EXECUTED
b7c4: 0a000016 beq b824 <rtems_bdbuf_purge+0x128> <== NOT EXECUTED
b7c8: e1a04003 mov r4, r3 <== NOT EXECUTED
b7cc: eaffffde b b74c <rtems_bdbuf_purge+0x50> <== NOT EXECUTED
case RTEMS_BDBUF_STATE_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
break;
case RTEMS_BDBUF_STATE_SYNC:
rtems_bdbuf_wake (&bdbuf_cache.transfer_waiters);
b7d0: e59f00e0 ldr r0, [pc, #224] ; b8b8 <rtems_bdbuf_purge+0x1bc>
b7d4: ebfffbc3 bl a6e8 <rtems_bdbuf_wake>
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
b7d8: e594302c ldr r3, [r4, #44] ; 0x2c
b7dc: e593200c ldr r2, [r3, #12]
b7e0: e2422001 sub r2, r2, #1
b7e4: e583200c str r2, [r3, #12]
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
b7e8: e1a00004 mov r0, r4
b7ec: ebffef78 bl 75d4 <_Chain_Extract>
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
b7f0: e1a00007 mov r0, r7
b7f4: e1a01004 mov r1, r4
b7f8: ebffef6a bl 75a8 <_Chain_Append>
default:
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_STATE_11);
}
}
if (cur->avl.left != NULL)
b7fc: e5943008 ldr r3, [r4, #8]
b800: e3530000 cmp r3, #0
b804: 1affffeb bne b7b8 <rtems_bdbuf_purge+0xbc>
/* Left */
++prev;
*prev = cur;
cur = cur->avl.left;
}
else if (cur->avl.right != NULL)
b808: e594300c ldr r3, [r4, #12]
b80c: e3530000 cmp r3, #0
b810: 0a000018 beq b878 <rtems_bdbuf_purge+0x17c>
{
/* Right */
++prev;
*prev = cur;
b814: e5a54004 str r4, [r5, #4]! <== NOT EXECUTED
cur = cur->avl.right;
b818: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
rtems_bdbuf_buffer **prev = stack;
rtems_bdbuf_buffer *cur = bdbuf_cache.tree;
*prev = NULL;
while (cur != NULL)
b81c: e3530000 cmp r3, #0 <== NOT EXECUTED
b820: 1affffe8 bne b7c8 <rtems_bdbuf_purge+0xcc> <== NOT EXECUTED
b824: e3a04000 mov r4, #0
b828: ea000003 b b83c <rtems_bdbuf_purge+0x140>
while ((node = rtems_chain_get (purge_list)) != NULL)
{
rtems_bdbuf_buffer *bd = (rtems_bdbuf_buffer *) node;
if (bd->waiters == 0)
b82c: e5933028 ldr r3, [r3, #40] ; 0x28
b830: e3530000 cmp r3, #0
b834: 03a04001 moveq r4, #1
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
b838: ebffff34 bl b510 <rtems_bdbuf_discard_buffer>
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
b83c: e1a00007 mov r0, r7
b840: ebffef6c bl 75f8 <_Chain_Get>
rtems_bdbuf_purge_list (rtems_chain_control *purge_list)
{
bool wake_buffer_waiters = false;
rtems_chain_node *node = NULL;
while ((node = rtems_chain_get (purge_list)) != NULL)
b844: e2503000 subs r3, r0, #0
b848: 1afffff7 bne b82c <rtems_bdbuf_purge+0x130>
wake_buffer_waiters = true;
rtems_bdbuf_discard_buffer (bd);
}
if (wake_buffer_waiters)
b84c: e3540000 cmp r4, #0
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
b850: 159f0064 ldrne r0, [pc, #100] ; b8bc <rtems_bdbuf_purge+0x1c0>
b854: 1bfffba3 blne a6e8 <rtems_bdbuf_wake>
rtems_chain_initialize_empty (&purge_list);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_gather_for_purge (&purge_list, compare, dev);
rtems_bdbuf_purge_list (&purge_list);
rtems_bdbuf_unlock_cache ();
b858: ebfffc17 bl a8bc <rtems_bdbuf_unlock_cache>
}
b85c: e28dd08c add sp, sp, #140 ; 0x8c
b860: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
b864: e584a024 str sl, [r4, #36] ; 0x24
b868: eaffffcf b b7ac <rtems_bdbuf_purge+0xb0>
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_set_state (cur, RTEMS_BDBUF_STATE_ACCESS_PURGED);
break;
default:
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_STATE_11);
b86c: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
b870: e2800001 add r0, r0, #1 <== NOT EXECUTED
b874: ebffee1f bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
*prev = cur;
cur = cur->avl.right;
}
else
{
while (*prev != NULL && cur == (*prev)->avl.right)
b878: e5951000 ldr r1, [r5]
b87c: e3510000 cmp r1, #0
b880: 0affffe7 beq b824 <rtems_bdbuf_purge+0x128>
b884: e591300c ldr r3, [r1, #12] <== NOT EXECUTED
b888: e1540003 cmp r4, r3 <== NOT EXECUTED
b88c: 0a000004 beq b8a4 <rtems_bdbuf_purge+0x1a8> <== NOT EXECUTED
b890: eaffffca b b7c0 <rtems_bdbuf_purge+0xc4> <== NOT EXECUTED
b894: e592300c ldr r3, [r2, #12] <== NOT EXECUTED
b898: e1530001 cmp r3, r1 <== NOT EXECUTED
b89c: 1affffc7 bne b7c0 <rtems_bdbuf_purge+0xc4> <== NOT EXECUTED
else if (cur->avl.right != NULL)
{
/* Right */
++prev;
*prev = cur;
cur = cur->avl.right;
b8a0: e1a01002 mov r1, r2 <== NOT EXECUTED
}
else
{
while (*prev != NULL && cur == (*prev)->avl.right)
b8a4: e5352004 ldr r2, [r5, #-4]! <== NOT EXECUTED
b8a8: e3520000 cmp r2, #0 <== NOT EXECUTED
b8ac: 1afffff8 bne b894 <rtems_bdbuf_purge+0x198> <== NOT EXECUTED
b8b0: eaffffdb b b824 <rtems_bdbuf_purge+0x128> <== NOT EXECUTED
0000a678 <rtems_bdbuf_purge_compare_dev>:
rtems_bdbuf_unlock_cache ();
}
static bool
rtems_bdbuf_purge_compare_dev (dev_t a, dev_t b)
{
a678: e1500002 cmp r0, r2
a67c: e3a00000 mov r0, #0
a680: 0a000001 beq a68c <rtems_bdbuf_purge_compare_dev+0x14>
return a == b;
}
a684: e2000001 and r0, r0, #1 <== NOT EXECUTED
a688: e12fff1e bx lr <== NOT EXECUTED
rtems_bdbuf_unlock_cache ();
}
static bool
rtems_bdbuf_purge_compare_dev (dev_t a, dev_t b)
{
a68c: e1510003 cmp r1, r3
a690: 03a00001 moveq r0, #1
return a == b; }
a694: e2000001 and r0, r0, #1
a698: e12fff1e bx lr
0000a69c <rtems_bdbuf_purge_compare_major>:
static bool
rtems_bdbuf_purge_compare_major (dev_t a, dev_t b)
{
return rtems_filesystem_dev_major_t (a) == rtems_filesystem_dev_major_t (b);
}
a69c: e1500002 cmp r0, r2 <== NOT EXECUTED
a6a0: 13a00000 movne r0, #0 <== NOT EXECUTED
a6a4: 03a00001 moveq r0, #1 <== NOT EXECUTED
a6a8: e12fff1e bx lr <== NOT EXECUTED
0000b8c0 <rtems_bdbuf_purge_major>:
return rtems_filesystem_dev_major_t (a) == rtems_filesystem_dev_major_t (b);
}
void
rtems_bdbuf_purge_major (rtems_device_major_number major)
{
b8c0: e1a01000 mov r1, r0 <== NOT EXECUTED
dev_t dev = rtems_filesystem_make_dev_t (major, 0);
rtems_bdbuf_purge (rtems_bdbuf_purge_compare_major, dev);
b8c4: e59f0004 ldr r0, [pc, #4] ; b8d0 <rtems_bdbuf_purge_major+0x10><== NOT EXECUTED
b8c8: e3a02000 mov r2, #0 <== NOT EXECUTED
b8cc: eaffff8a b b6fc <rtems_bdbuf_purge> <== NOT EXECUTED
0000c85c <rtems_bdbuf_read>:
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
c85c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
c860: e28db020 add fp, sp, #32
rtems_blkdev_request *req = NULL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
c864: e24be028 sub lr, fp, #40 ; 0x28
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
c868: e24dd02c sub sp, sp, #44 ; 0x2c
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_disk_device *dd = NULL;
c86c: e3a0c000 mov ip, #0
rtems_status_code
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
c870: e50b3034 str r3, [fp, #-52] ; 0x34
rtems_blkdev_request *req = NULL;
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block = 0;
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
c874: e58de000 str lr, [sp]
c878: e24b3024 sub r3, fp, #36 ; 0x24
c87c: e24be02c sub lr, fp, #44 ; 0x2c
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_disk_device *dd = NULL; rtems_blkdev_request *req = NULL; rtems_bdbuf_buffer *bd = NULL; rtems_blkdev_bnum media_block = 0; size_t bds_per_group = 0;
c880: e50bc02c str ip, [fp, #-44] ; 0x2c
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
c884: e58de004 str lr, [sp, #4]
rtems_bdbuf_read (dev_t dev,
rtems_blkdev_bnum block,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
c888: e50bc024 str ip, [fp, #-36] ; 0x24
rtems_blkdev_request *req = NULL; rtems_bdbuf_buffer *bd = NULL; rtems_blkdev_bnum media_block = 0;
c88c: e50bc028 str ip, [fp, #-40] ; 0x28
size_t bds_per_group = 0;
sc = rtems_bdbuf_obtain_disk (dev, block, &dd, &media_block, &bds_per_group);
c890: ebfff81d bl a90c <rtems_bdbuf_obtain_disk>
if (sc != RTEMS_SUCCESSFUL)
c894: e2508000 subs r8, r0, #0
c898: 11a04008 movne r4, r8
c89c: 0a000002 beq c8ac <rtems_bdbuf_read+0x50>
rtems_bdbuf_unlock_cache ();
rtems_bdbuf_release_disk (dd);
return sc;
}
c8a0: e1a00004 mov r0, r4
c8a4: e24bd020 sub sp, fp, #32
c8a8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
/*
* TODO: This type of request structure is wrong and should be removed.
*/
#define bdbuf_alloc(size) __builtin_alloca (size)
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
c8ac: e59f32b4 ldr r3, [pc, #692] ; cb68 <rtems_bdbuf_read+0x30c>
c8b0: e5933000 ldr r3, [r3]
c8b4: e2833001 add r3, r3, #1
c8b8: e50b3030 str r3, [fp, #-48] ; 0x30
c8bc: e1a03203 lsl r3, r3, #4
c8c0: e283301c add r3, r3, #28
c8c4: e04dd003 sub sp, sp, r3
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
c8c8: ebfff780 bl a6d0 <rtems_bdbuf_lock_cache>
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
c8cc: e51b9024 ldr r9, [fp, #-36] ; 0x24
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
c8d0: e599c020 ldr ip, [r9, #32]
c8d4: e5991024 ldr r1, [r9, #36] ; 0x24
c8d8: e1a0000c mov r0, ip
c8dc: e50bc044 str ip, [fp, #-68] ; 0x44
c8e0: eb003b61 bl 1b66c <__aeabi_uidiv>
size_t bds_per_group,
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
c8e4: e5992018 ldr r2, [r9, #24]
if (media_block_end - media_block < transfer_count)
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
c8e8: e59f327c ldr r3, [pc, #636] ; cb6c <rtems_bdbuf_read+0x310>
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
c8ec: e51b102c ldr r1, [fp, #-44] ; 0x2c
/*
* TODO: This type of request structure is wrong and should be removed.
*/
#define bdbuf_alloc(size) __builtin_alloca (size)
req = bdbuf_alloc (sizeof (rtems_blkdev_request) +
c8f0: e28d7008 add r7, sp, #8
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
dev_t dev = dd->dev;
c8f4: e5995004 ldr r5, [r9, #4]
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
c8f8: e51b6028 ldr r6, [fp, #-40] ; 0x28
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
dev_t dev = dd->dev;
c8fc: e5994000 ldr r4, [r9]
if (media_block_end - media_block < transfer_count)
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
c900: e5873004 str r3, [r7, #4]
uint32_t transfer_count = bdbuf_config.max_read_ahead_blocks + 1;
if (media_block_end - media_block < transfer_count)
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
c904: e5878000 str r8, [r7]
if (rtems_bdbuf_tracer)
printf ("bdbuf:read: %" PRIu32 " (%" PRIu32 ") (dev = %08x)\n",
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
c908: e50b103c str r1, [fp, #-60] ; 0x3c
size_t bds_per_group,
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
c90c: e50b2038 str r2, [fp, #-56] ; 0x38
rtems_blkdev_bnum media_block_count = dd->block_size / dd->media_block_size;
c910: e1a0a000 mov sl, r0
if (media_block_end - media_block < transfer_count)
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
c914: e5877008 str r7, [r7, #8]
size_t bds_per_group,
rtems_blkdev_request *req,
rtems_bdbuf_buffer **bd_ptr)
{
rtems_bdbuf_buffer *bd = NULL;
rtems_blkdev_bnum media_block_end = dd->start + dd->size;
c918: e599901c ldr r9, [r9, #28]
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
req->io_task = rtems_task_self ();
c91c: eb000b68 bl f6c4 <rtems_task_self>
req->status = RTEMS_RESOURCE_IN_USE;
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
c920: e1a02006 mov r2, r6
transfer_count = media_block_end - media_block;
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
req->io_task = rtems_task_self ();
c924: e5870014 str r0, [r7, #20]
req->status = RTEMS_RESOURCE_IN_USE;
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
c928: e51b303c ldr r3, [fp, #-60] ; 0x3c
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
req->io_task = rtems_task_self ();
req->status = RTEMS_RESOURCE_IN_USE;
c92c: e3a0e00c mov lr, #12
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
c930: e1a00004 mov r0, r4
c934: e1a01005 mov r1, r5
req->req = RTEMS_BLKDEV_REQ_READ; req->req_done = rtems_bdbuf_transfer_done; req->done_arg = req; req->io_task = rtems_task_self (); req->status = RTEMS_RESOURCE_IN_USE; req->bufnum = 0;
c938: e5878010 str r8, [r7, #16]
req->req = RTEMS_BLKDEV_REQ_READ;
req->req_done = rtems_bdbuf_transfer_done;
req->done_arg = req;
req->io_task = rtems_task_self ();
req->status = RTEMS_RESOURCE_IN_USE;
c93c: e587e00c str lr, [r7, #12]
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
c940: ebfffeff bl c544 <rtems_bdbuf_get_buffer_for_access>
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
c944: e5903024 ldr r3, [r0, #36] ; 0x24
*bd_ptr = bd;
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
req->bufs [0].buffer = bd->buffer;
c948: e5902020 ldr r2, [r0, #32]
*bd_ptr = bd;
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
c94c: e51bc044 ldr ip, [fp, #-68] ; 0x44
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
c950: e3530002 cmp r3, #2
req->done_arg = req;
req->io_task = rtems_task_self ();
req->status = RTEMS_RESOURCE_IN_USE;
req->bufnum = 0;
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
c954: e1a08000 mov r8, r0
*bd_ptr = bd;
req->bufs [0].user = bd;
req->bufs [0].block = media_block;
req->bufs [0].length = block_size;
req->bufs [0].buffer = bd->buffer;
c958: e5872020 str r2, [r7, #32]
bd = rtems_bdbuf_get_buffer_for_access (dev, media_block, bds_per_group);
*bd_ptr = bd;
req->bufs [0].user = bd;
c95c: e5870024 str r0, [r7, #36] ; 0x24
req->bufs [0].block = media_block;
c960: e5876018 str r6, [r7, #24]
req->bufs [0].length = block_size;
c964: e587c01c str ip, [r7, #28]
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
c968: 0a00005e beq cae8 <rtems_bdbuf_read+0x28c>
c96c: e3530007 cmp r3, #7
c970: 0a00005c beq cae8 <rtems_bdbuf_read+0x28c>
c974: e3530001 cmp r3, #1
c978: 0a000004 beq c990 <rtems_bdbuf_read+0x134>
return;
case RTEMS_BDBUF_STATE_EMPTY:
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
c97c: e5900024 ldr r0, [r0, #36] ; 0x24 <== NOT EXECUTED
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
c980: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
c984: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
c988: e380001d orr r0, r0, #29 <== NOT EXECUTED
c98c: ebffe9d9 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
c990: e51be038 ldr lr, [fp, #-56] ; 0x38
c994: e089900e add r9, r9, lr
c998: e51b2030 ldr r2, [fp, #-48] ; 0x30
c99c: e0669009 rsb r9, r6, r9
c9a0: e1a01009 mov r1, r9
c9a4: e1510002 cmp r1, r2
c9a8: 21a01002 movcs r1, r2
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
break;
}
while (transfer_index < transfer_count)
c9ac: e3510001 cmp r1, #1
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c9b0: e3a02009 mov r2, #9
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
c9b4: e50b1040 str r1, [fp, #-64] ; 0x40
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c9b8: e5802024 str r2, [r0, #36] ; 0x24
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
break;
}
while (transfer_index < transfer_count)
c9bc: 950b3030 strls r3, [fp, #-48] ; 0x30
c9c0: 9a00002c bls ca78 <rtems_bdbuf_read+0x21c>
c9c4: e59f91a4 ldr r9, [pc, #420] ; cb70 <rtems_bdbuf_read+0x314>
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
c9c8: e50b3030 str r3, [fp, #-48] ; 0x30
c9cc: e50b7038 str r7, [fp, #-56] ; 0x38
static rtems_bdbuf_buffer *
rtems_bdbuf_avl_search (rtems_bdbuf_buffer** root,
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
c9d0: e5993040 ldr r3, [r9, #64] ; 0x40
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
c9d4: e3530000 cmp r3, #0
break;
}
while (transfer_index < transfer_count)
{
media_block += media_block_count;
c9d8: e086600a add r6, r6, sl
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
c9dc: 0a000008 beq ca04 <rtems_bdbuf_read+0x1a8>
c9e0: e5932014 ldr r2, [r3, #20]
c9e4: e1540002 cmp r4, r2
c9e8: e5931018 ldr r1, [r3, #24]
c9ec: 0a000035 beq cac8 <rtems_bdbuf_read+0x26c>
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
c9f0: e1550001 cmp r5, r1 <== NOT EXECUTED
c9f4: 9a00002e bls cab4 <rtems_bdbuf_read+0x258> <== NOT EXECUTED
{
p = p->avl.right;
c9f8: e593300c ldr r3, [r3, #12]
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
c9fc: e3530000 cmp r3, #0
ca00: 1afffff6 bne c9e0 <rtems_bdbuf_read+0x184>
bd = rtems_bdbuf_avl_search (&bdbuf_cache.tree, dev, block);
if (bd == NULL)
{
bd = rtems_bdbuf_get_buffer_from_lru_list (dev, block, bds_per_group);
ca04: e1a00004 mov r0, r4
ca08: e1a01005 mov r1, r5
ca0c: e1a02006 mov r2, r6
ca10: e51b303c ldr r3, [fp, #-60] ; 0x3c
ca14: e50bc044 str ip, [fp, #-68] ; 0x44
ca18: ebfffdcf bl c15c <rtems_bdbuf_get_buffer_from_lru_list>
if (bd != NULL)
ca1c: e3500000 cmp r0, #0
ca20: e51bc044 ldr ip, [fp, #-68] ; 0x44
ca24: 0a000013 beq ca78 <rtems_bdbuf_read+0x21c>
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ca28: e590302c ldr r3, [r0, #44] ; 0x2c <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
ca2c: e51be030 ldr lr, [fp, #-48] ; 0x30 <== NOT EXECUTED
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ca30: e593100c ldr r1, [r3, #12] <== NOT EXECUTED
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
break;
}
while (transfer_index < transfer_count)
ca34: e51b2040 ldr r2, [fp, #-64] ; 0x40 <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
ca38: e28ee001 add lr, lr, #1 <== NOT EXECUTED
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
ca3c: e2811001 add r1, r1, #1 <== NOT EXECUTED
ca40: e583100c str r1, [r3, #12] <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
ca44: e50be030 str lr, [fp, #-48] ; 0x30 <== NOT EXECUTED
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
break;
}
while (transfer_index < transfer_count)
ca48: e15e0002 cmp lr, r2 <== NOT EXECUTED
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
req->bufs [transfer_index].block = media_block;
req->bufs [transfer_index].length = block_size;
req->bufs [transfer_index].buffer = bd->buffer;
ca4c: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED
ca50: e51be038 ldr lr, [fp, #-56] ; 0x38 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ca54: e3a01009 mov r1, #9 <== NOT EXECUTED
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
req->bufs [transfer_index].block = media_block;
req->bufs [transfer_index].length = block_size;
req->bufs [transfer_index].buffer = bd->buffer;
ca58: e58e3030 str r3, [lr, #48] ; 0x30 <== NOT EXECUTED
if (bd == NULL)
break;
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_TRANSFER);
req->bufs [transfer_index].user = bd;
ca5c: e58e0034 str r0, [lr, #52] ; 0x34 <== NOT EXECUTED
req->bufs [transfer_index].block = media_block;
ca60: e58e6028 str r6, [lr, #40] ; 0x28 <== NOT EXECUTED
req->bufs [transfer_index].length = block_size;
ca64: e58ec02c str ip, [lr, #44] ; 0x2c <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
ca68: e28ee010 add lr, lr, #16 <== NOT EXECUTED
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
ca6c: e5801024 str r1, [r0, #36] ; 0x24 <== NOT EXECUTED
req->bufs [transfer_index].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
ca70: e50be038 str lr, [fp, #-56] ; 0x38 <== NOT EXECUTED
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_1);
break;
}
while (transfer_index < transfer_count)
ca74: 3affffd5 bcc c9d0 <rtems_bdbuf_read+0x174> <== NOT EXECUTED
rtems_bdbuf_show_users ("read-ahead", bd);
++transfer_index;
}
req->bufnum = transfer_index;
ca78: e51b2030 ldr r2, [fp, #-48] ; 0x30
ca7c: e5872010 str r2, [r7, #16]
media_block + dd->start, block, (unsigned) dev);
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
if (req->bufnum > 0)
ca80: e51b3030 ldr r3, [fp, #-48] ; 0x30
ca84: e3530000 cmp r3, #0
ca88: 1a000019 bne caf4 <rtems_bdbuf_read+0x298>
}
}
if (sc == RTEMS_SUCCESSFUL)
{
switch (bd->state)
ca8c: e5983024 ldr r3, [r8, #36] ; 0x24
ca90: e3530002 cmp r3, #2
ca94: 0a000029 beq cb40 <rtems_bdbuf_read+0x2e4>
ca98: e3530007 cmp r3, #7
ca9c: 0a000021 beq cb28 <rtems_bdbuf_read+0x2cc>
break;
case RTEMS_BDBUF_STATE_MODIFIED:
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_ACCESS_MODIFIED);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_4);
caa0: e5980024 ldr r0, [r8, #36] ; 0x24 <== NOT EXECUTED
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
caa4: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
caa8: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
caac: e3800002 orr r0, r0, #2 <== NOT EXECUTED
cab0: ebffe990 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
cab4: 1a000001 bne cac0 <rtems_bdbuf_read+0x264> <== NOT EXECUTED
cab8: e1540002 cmp r4, r2 <== NOT EXECUTED
cabc: 8affffcd bhi c9f8 <rtems_bdbuf_read+0x19c> <== NOT EXECUTED
{
p = p->avl.right;
}
else
{
p = p->avl.left;
cac0: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
cac4: eaffffcc b c9fc <rtems_bdbuf_read+0x1a0> <== NOT EXECUTED
dev_t dev,
rtems_blkdev_bnum block)
{
rtems_bdbuf_buffer* p = *root;
while ((p != NULL) && ((p->dev != dev) || (p->block != block)))
cac8: e1550001 cmp r5, r1
cacc: 1affffc7 bne c9f0 <rtems_bdbuf_read+0x194>
cad0: e593201c ldr r2, [r3, #28]
cad4: e1560002 cmp r6, r2
cad8: 0affffe6 beq ca78 <rtems_bdbuf_read+0x21c>
{
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
cadc: 8affffc5 bhi c9f8 <rtems_bdbuf_read+0x19c>
{
p = p->avl.right;
}
else
{
p = p->avl.left;
cae0: e5933008 ldr r3, [r3, #8] <== NOT EXECUTED
cae4: eaffffc4 b c9fc <rtems_bdbuf_read+0x1a0> <== NOT EXECUTED
req->bufs [0].buffer = bd->buffer;
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_users ("read", bd);
switch (bd->state)
cae8: e5973010 ldr r3, [r7, #16]
caec: e50b3030 str r3, [fp, #-48] ; 0x30
caf0: eaffffe2 b ca80 <rtems_bdbuf_read+0x224>
rtems_bdbuf_lock_cache ();
rtems_bdbuf_create_read_request (dd, media_block, bds_per_group, req, &bd);
if (req->bufnum > 0)
{
sc = rtems_bdbuf_execute_transfer_request (dd, req, true);
caf4: e1a01007 mov r1, r7
caf8: e51b0024 ldr r0, [fp, #-36] ; 0x24
cafc: e3a02001 mov r2, #1
cb00: ebfffb78 bl b8e8 <rtems_bdbuf_execute_transfer_request>
if (sc == RTEMS_SUCCESSFUL)
cb04: e2504000 subs r4, r0, #0
cb08: 0a00000f beq cb4c <rtems_bdbuf_read+0x2f0>
}
*bd_ptr = bd;
}
else
*bd_ptr = NULL;
cb0c: e51b1034 ldr r1, [fp, #-52] ; 0x34
cb10: e3a03000 mov r3, #0
cb14: e5813000 str r3, [r1]
rtems_bdbuf_unlock_cache ();
cb18: ebfff767 bl a8bc <rtems_bdbuf_unlock_cache>
rtems_bdbuf_release_disk (dd);
cb1c: e51b0024 ldr r0, [fp, #-36] ; 0x24
cb20: ebfff7b7 bl aa04 <rtems_bdbuf_release_disk>
return sc;
cb24: eaffff5d b c8a0 <rtems_bdbuf_read+0x44>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
cb28: e3a03004 mov r3, #4
cb2c: e5883024 str r3, [r8, #36] ; 0x24
{
rtems_bdbuf_show_users ("read", bd);
rtems_bdbuf_show_usage ();
}
*bd_ptr = bd;
cb30: e51be034 ldr lr, [fp, #-52] ; 0x34
cb34: e3a04000 mov r4, #0
cb38: e58e8000 str r8, [lr]
cb3c: eafffff5 b cb18 <rtems_bdbuf_read+0x2bc>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
cb40: e3a03003 mov r3, #3
cb44: e5883024 str r3, [r8, #36] ; 0x24
cb48: eafffff8 b cb30 <rtems_bdbuf_read+0x2d4>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
cb4c: e1a00008 mov r0, r8
cb50: ebffea9f bl 75d4 <_Chain_Extract>
}
static void
rtems_bdbuf_group_obtain (rtems_bdbuf_buffer *bd)
{
++bd->group->users;
cb54: e598302c ldr r3, [r8, #44] ; 0x2c
cb58: e593200c ldr r2, [r3, #12]
cb5c: e2822001 add r2, r2, #1
cb60: e583200c str r2, [r3, #12]
cb64: eaffffc8 b ca8c <rtems_bdbuf_read+0x230>
0000b618 <rtems_bdbuf_release>:
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
b618: e59f30cc ldr r3, [pc, #204] ; b6ec <rtems_bdbuf_release+0xd4>
b61c: e5d33088 ldrb r3, [r3, #136] ; 0x88
b620: e3530000 cmp r3, #0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release (rtems_bdbuf_buffer *bd)
{
b624: e92d4010 push {r4, lr}
b628: e1a04000 mov r4, r0
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
b62c: 03a00016 moveq r0, #22
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
b630: 08bd8010 popeq {r4, pc}
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
b634: e3540000 cmp r4, #0
b638: 03a00009 moveq r0, #9
b63c: 08bd8010 popeq {r4, pc}
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
b640: ebfffc22 bl a6d0 <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
b644: e5943024 ldr r3, [r4, #36] ; 0x24
b648: e2433003 sub r3, r3, #3
b64c: e3530003 cmp r3, #3
b650: 979ff103 ldrls pc, [pc, r3, lsl #2]
b654: ea00001c b b6cc <rtems_bdbuf_release+0xb4> <== NOT EXECUTED
b658: 0000b690 .word 0x0000b690 <== NOT EXECUTED
b65c: 0000b67c .word 0x0000b67c <== NOT EXECUTED
b660: 0000b668 .word 0x0000b668 <== NOT EXECUTED
b664: 0000b668 .word 0x0000b668 <== NOT EXECUTED
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
rtems_bdbuf_add_to_lru_list_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
b668: e1a00004 mov r0, r4
b66c: ebffffb5 bl b548 <rtems_bdbuf_discard_buffer_after_access>
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
b670: ebfffc91 bl a8bc <rtems_bdbuf_unlock_cache>
b674: e3a00000 mov r0, #0
return RTEMS_SUCCESSFUL;
}
b678: e8bd8010 pop {r4, pc}
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
b67c: e1a00004 mov r0, r4
b680: ebfffcf1 bl aa4c <rtems_bdbuf_add_to_modified_list_after_access>
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
b684: ebfffc8c bl a8bc <rtems_bdbuf_unlock_cache>
b688: e3a00000 mov r0, #0
return RTEMS_SUCCESSFUL;
}
b68c: e8bd8010 pop {r4, pc}
}
static void
rtems_bdbuf_group_release (rtems_bdbuf_buffer *bd)
{
--bd->group->users;
b690: e594302c ldr r3, [r4, #44] ; 0x2c
b694: e593200c ldr r2, [r3, #12]
b698: e2422001 sub r2, r2, #1
b69c: e583200c str r2, [r3, #12]
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
b6a0: e3a03002 mov r3, #2
b6a4: e5843024 str r3, [r4, #36] ; 0x24
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
b6a8: e59f0040 ldr r0, [pc, #64] ; b6f0 <rtems_bdbuf_release+0xd8>
b6ac: e1a01004 mov r1, r4
b6b0: ebffefbc bl 75a8 <_Chain_Append>
rtems_bdbuf_add_to_lru_list_after_access (rtems_bdbuf_buffer *bd)
{
rtems_bdbuf_group_release (bd);
rtems_bdbuf_make_cached_and_add_to_lru_list (bd);
if (bd->waiters)
b6b4: e5943028 ldr r3, [r4, #40] ; 0x28
b6b8: e3530000 cmp r3, #0
b6bc: 0a000007 beq b6e0 <rtems_bdbuf_release+0xc8>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
b6c0: e59f002c ldr r0, [pc, #44] ; b6f4 <rtems_bdbuf_release+0xdc>
b6c4: ebfffc07 bl a6e8 <rtems_bdbuf_wake>
b6c8: eaffffe8 b b670 <rtems_bdbuf_release+0x58>
break;
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_0);
b6cc: e5940024 ldr r0, [r4, #36] ; 0x24 <== NOT EXECUTED
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
b6d0: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
b6d4: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
b6d8: e380001c orr r0, r0, #28 <== NOT EXECUTED
b6dc: ebffee85 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_bdbuf_make_cached_and_add_to_lru_list (bd);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
else
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
b6e0: e59f0010 ldr r0, [pc, #16] ; b6f8 <rtems_bdbuf_release+0xe0>
b6e4: ebfffbff bl a6e8 <rtems_bdbuf_wake>
b6e8: eaffffe0 b b670 <rtems_bdbuf_release+0x58>
0000aa04 <rtems_bdbuf_release_disk>:
return RTEMS_SUCCESSFUL;
}
static void
rtems_bdbuf_release_disk (rtems_disk_device *dd)
{
aa04: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_disk_release (dd);
aa08: ebffde34 bl 22e0 <rtems_disk_release>
if (sc != RTEMS_SUCCESSFUL)
aa0c: e3500000 cmp r0, #0
aa10: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_DISK_REL);
aa14: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
aa18: e280001f add r0, r0, #31 <== NOT EXECUTED
aa1c: ebfff1b5 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000b590 <rtems_bdbuf_release_modified>:
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
b590: e59f307c ldr r3, [pc, #124] ; b614 <rtems_bdbuf_release_modified+0x84>
b594: e5d33088 ldrb r3, [r3, #136] ; 0x88
b598: e3530000 cmp r3, #0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_release_modified (rtems_bdbuf_buffer *bd)
{
b59c: e92d4010 push {r4, lr}
b5a0: e1a04000 mov r4, r0
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
b5a4: 03a00016 moveq r0, #22
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
b5a8: 08bd8010 popeq {r4, pc}
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
b5ac: e3540000 cmp r4, #0
b5b0: 03a00009 moveq r0, #9
b5b4: 08bd8010 popeq {r4, pc}
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
b5b8: ebfffc44 bl a6d0 <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "release modified");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
b5bc: e5943024 ldr r3, [r4, #36] ; 0x24
b5c0: e3530003 cmp r3, #3
b5c4: 3a000003 bcc b5d8 <rtems_bdbuf_release_modified+0x48>
b5c8: e3530005 cmp r3, #5
b5cc: 9a00000b bls b600 <rtems_bdbuf_release_modified+0x70>
b5d0: e3530006 cmp r3, #6
b5d4: 0a000004 beq b5ec <rtems_bdbuf_release_modified+0x5c>
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_6);
b5d8: e5940024 ldr r0, [r4, #36] ; 0x24 <== NOT EXECUTED
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
b5dc: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
b5e0: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
b5e4: e3800004 orr r0, r0, #4 <== NOT EXECUTED
b5e8: ebffeec2 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
b5ec: e1a00004 mov r0, r4
b5f0: ebffffd4 bl b548 <rtems_bdbuf_discard_buffer_after_access>
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
b5f4: ebfffcb0 bl a8bc <rtems_bdbuf_unlock_cache>
b5f8: e3a00000 mov r0, #0
return RTEMS_SUCCESSFUL;
}
b5fc: e8bd8010 pop {r4, pc}
switch (bd->state)
{
case RTEMS_BDBUF_STATE_ACCESS_CACHED:
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_add_to_modified_list_after_access (bd);
b600: e1a00004 mov r0, r4
b604: ebfffd10 bl aa4c <rtems_bdbuf_add_to_modified_list_after_access>
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
b608: ebfffcab bl a8bc <rtems_bdbuf_unlock_cache>
b60c: e3a00000 mov r0, #0
return RTEMS_SUCCESSFUL;
}
b610: e8bd8010 pop {r4, pc}
0000b184 <rtems_bdbuf_remove_from_tree>:
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
b184: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
b188: e59fb33c ldr fp, [pc, #828] ; b4cc <rtems_bdbuf_remove_from_tree+0x348>
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
b18c: e24dd080 sub sp, sp, #128 ; 0x80
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
rtems_blkdev_bnum block = node->block;
rtems_bdbuf_buffer* p = *root;
b190: e59b4040 ldr r4, [fp, #64] ; 0x40
return bdbuf_cache.buffer_waiters.count;
}
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
b194: e1a08000 mov r8, r0
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
b198: e3a01000 mov r1, #0
b19c: e1a0000d mov r0, sp
b1a0: e3a02080 mov r2, #128 ; 0x80
*/
static int
rtems_bdbuf_avl_remove(rtems_bdbuf_buffer** root,
const rtems_bdbuf_buffer* node)
{
dev_t dev = node->dev;
b1a4: e5986014 ldr r6, [r8, #20]
b1a8: e2885018 add r5, r8, #24
b1ac: e8950420 ldm r5, {r5, sl}
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
b1b0: eb001e57 bl 12b14 <memset>
while (p != NULL)
b1b4: e3540000 cmp r4, #0
rtems_bdbuf_buffer* buf_stack[RTEMS_BDBUF_AVL_MAX_HEIGHT];
rtems_bdbuf_buffer** buf_prev = buf_stack;
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
b1b8: e1a0700d mov r7, sp
while (p != NULL)
b1bc: 0a000017 beq b220 <rtems_bdbuf_remove_from_tree+0x9c>
b1c0: e1a0100d mov r1, sp
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
{
p->avl.cache = 1;
b1c4: e3a0c001 mov ip, #1
p = p->avl.right;
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
b1c8: e3e09000 mvn r9, #0
b1cc: ea000009 b b1f8 <rtems_bdbuf_remove_from_tree+0x74>
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
b1d0: 1a000001 bne b1dc <rtems_bdbuf_remove_from_tree+0x58>
b1d4: e1560000 cmp r6, r0
b1d8: 8a00000c bhi b210 <rtems_bdbuf_remove_from_tree+0x8c>
b1dc: e1560000 cmp r6, r0
b1e0: 0a000013 beq b234 <rtems_bdbuf_remove_from_tree+0xb0>
p->avl.cache = 1;
p = p->avl.right;
}
else if ((p->dev != dev) || (p->block != block))
{
p->avl.cache = -1;
b1e4: e5c49010 strb r9, [r4, #16]
p = p->avl.left;
b1e8: e5944008 ldr r4, [r4, #8]
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
b1ec: e3540000 cmp r4, #0
b1f0: 0a00000a beq b220 <rtems_bdbuf_remove_from_tree+0x9c>
b1f4: e1a01003 mov r1, r3
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
b1f8: e5942018 ldr r2, [r4, #24]
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
b1fc: e1a03001 mov r3, r1
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
b200: e1550002 cmp r5, r2
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
{
*buf_prev++ = p;
b204: e4834004 str r4, [r3], #4
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
b208: e5940014 ldr r0, [r4, #20]
b20c: 9affffef bls b1d0 <rtems_bdbuf_remove_from_tree+0x4c>
{
p->avl.cache = 1;
b210: e5c4c010 strb ip, [r4, #16]
p = p->avl.right;
b214: e594400c ldr r4, [r4, #12]
bool modified = false;
memset (buf_stack, 0, sizeof(buf_stack));
while (p != NULL)
b218: e3540000 cmp r4, #0
b21c: 1afffff4 bne b1f4 <rtems_bdbuf_remove_from_tree+0x70>
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);
b220: e5980024 ldr r0, [r8, #36] ; 0x24 <== NOT EXECUTED
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
b224: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
b228: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
b22c: e3800009 orr r0, r0, #9 <== NOT EXECUTED
b230: ebffefb0 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
while (p != NULL)
{
*buf_prev++ = p;
if ((p->dev < dev) || ((p->dev == dev) && (p->block < block)))
b234: e1550002 cmp r5, r2
b238: 1affffe9 bne b1e4 <rtems_bdbuf_remove_from_tree+0x60>
b23c: e594201c ldr r2, [r4, #28]
b240: e15a0002 cmp sl, r2
b244: 8afffff1 bhi b210 <rtems_bdbuf_remove_from_tree+0x8c>
{
p->avl.cache = 1;
p = p->avl.right;
}
else if ((p->dev != dev) || (p->block != block))
b248: 1affffe5 bne b1e4 <rtems_bdbuf_remove_from_tree+0x60>
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
b24c: e594200c ldr r2, [r4, #12]
}
q = p;
buf_prev--;
if (buf_prev > buf_stack)
b250: e1510007 cmp r1, r7
b254: 93a06000 movls r6, #0
{
p = *(buf_prev - 1);
b258: 85116004 ldrhi r6, [r1, #-4]
{
p = NULL;
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
b25c: e3520000 cmp r2, #0
b260: 0a00008b beq b494 <rtems_bdbuf_remove_from_tree+0x310>
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
b264: e5920008 ldr r0, [r2, #8]
b268: e3500000 cmp r0, #0
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
b26c: 13e05000 mvnne r5, #0
{
rtems_bdbuf_buffer **t;
r = q->avl.right;
if (r->avl.left == NULL)
b270: 0a00008d beq b4ac <rtems_bdbuf_remove_from_tree+0x328>
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
b274: e4832004 str r2, [r3], #4 <== NOT EXECUTED
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
*buf_prev++ = q = r;
b278: e1a00002 mov r0, r2 <== NOT EXECUTED
s = r;
while (s->avl.left != NULL)
{
*buf_prev++ = r = s;
s = r->avl.left;
b27c: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
b280: e592c008 ldr ip, [r2, #8] <== NOT EXECUTED
b284: e35c0000 cmp ip, #0 <== NOT EXECUTED
{
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
b288: e5c05010 strb r5, [r0, #16] <== NOT EXECUTED
else
{
t = buf_prev++;
s = r;
while (s->avl.left != NULL)
b28c: 1afffff8 bne b274 <rtems_bdbuf_remove_from_tree+0xf0> <== NOT EXECUTED
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
b290: e5948008 ldr r8, [r4, #8] <== NOT EXECUTED
r->avl.left = s->avl.right;
b294: e592500c ldr r5, [r2, #12] <== NOT EXECUTED
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
b298: e5d4c011 ldrb ip, [r4, #17] <== NOT EXECUTED
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
b29c: e594400c ldr r4, [r4, #12] <== NOT EXECUTED
*buf_prev++ = r = s;
s = r->avl.left;
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
b2a0: e5828008 str r8, [r2, #8] <== NOT EXECUTED
r->avl.left = s->avl.right;
b2a4: e5805008 str r5, [r0, #8] <== NOT EXECUTED
s->avl.right = q->avl.right;
s->avl.bal = q->avl.bal;
s->avl.cache = 1;
b2a8: e3a00001 mov r0, #1 <== NOT EXECUTED
r->avl.cache = -1;
}
s->avl.left = q->avl.left;
r->avl.left = s->avl.right;
s->avl.right = q->avl.right;
b2ac: e582400c str r4, [r2, #12] <== NOT EXECUTED
s->avl.bal = q->avl.bal;
b2b0: e5c2c011 strb ip, [r2, #17] <== NOT EXECUTED
s->avl.cache = 1;
b2b4: e5c20010 strb r0, [r2, #16] <== NOT EXECUTED
*t = q = s;
b2b8: e5812000 str r2, [r1] <== NOT EXECUTED
}
}
if (p != NULL)
b2bc: e3560000 cmp r6, #0
p->avl.right = q;
}
}
else
{
*root = q;
b2c0: 058b2040 streq r2, [fp, #64] ; 0x40
*t = q = s;
}
}
if (p != NULL)
b2c4: 0a000003 beq b2d8 <rtems_bdbuf_remove_from_tree+0x154>
{
if (p->avl.cache == -1)
b2c8: e1d611d0 ldrsb r1, [r6, #16]
b2cc: e3710001 cmn r1, #1
{
p->avl.left = q;
b2d0: 05862008 streq r2, [r6, #8]
}
else
{
p->avl.right = q;
b2d4: 1586200c strne r2, [r6, #12]
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
b2d8: e1530007 cmp r3, r7
{
case -1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = 1;
b2dc: 83a06001 movhi r6, #1
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
p = p2;
p2->avl.bal = 0;
b2e0: 83a04000 movhi r4, #0
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
b2e4: 83e05000 mvnhi r5, #0
modified = true;
while (modified)
{
if (buf_prev > buf_stack)
b2e8: 8a000016 bhi b348 <rtems_bdbuf_remove_from_tree+0x1c4>
b2ec: ea000028 b b394 <rtems_bdbuf_remove_from_tree+0x210>
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
b2f0: e1d201d1 ldrsb r0, [r2, #17]
b2f4: e3500000 cmp r0, #0
case +1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = -1;
b2f8: 05c25011 strbeq r5, [r2, #17]
b2fc: 01a01002 moveq r1, r2
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
b300: 0a000007 beq b324 <rtems_bdbuf_remove_from_tree+0x1a0>
b304: e3500001 cmp r0, #1
{
case +1:
p->avl.bal = 0;
b308: 05c24011 strbeq r4, [r2, #17]
b30c: 01a01002 moveq r1, r2
}
}
else
{
/* rebalance right branch */
switch (p->avl.bal)
b310: 0a000003 beq b324 <rtems_bdbuf_remove_from_tree+0x1a0>
b314: e3700001 cmn r0, #1 <== NOT EXECUTED
b318: 0a00001f beq b39c <rtems_bdbuf_remove_from_tree+0x218> <== NOT EXECUTED
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
p = p2;
p2->avl.bal = 0;
b31c: e1a01002 mov r1, r2 <== NOT EXECUTED
b320: e3a00001 mov r0, #1 <== NOT EXECUTED
default:
break;
}
}
if (buf_prev > buf_stack)
b324: e1530007 cmp r3, r7
b328: 9a000018 bls b390 <rtems_bdbuf_remove_from_tree+0x20c>
{
q = *(buf_prev - 1);
b32c: e5132004 ldr r2, [r3, #-4] <== NOT EXECUTED
if (q->avl.cache == -1)
b330: e1d2c1d0 ldrsb ip, [r2, #16] <== NOT EXECUTED
b334: e37c0001 cmn ip, #1 <== NOT EXECUTED
{
q->avl.left = p;
b338: 05821008 streq r1, [r2, #8] <== NOT EXECUTED
}
else
{
q->avl.right = p;
b33c: 1582100c strne r1, [r2, #12] <== NOT EXECUTED
*root = q;
}
modified = true;
while (modified)
b340: e3500000 cmp r0, #0 <== NOT EXECUTED
b344: 0a000012 beq b394 <rtems_bdbuf_remove_from_tree+0x210> <== NOT EXECUTED
{
if (buf_prev > buf_stack)
{
p = *--buf_prev;
b348: e5332004 ldr r2, [r3, #-4]!
else
{
break;
}
if (p->avl.cache == -1)
b34c: e1d2c1d0 ldrsb ip, [r2, #16]
b350: e37c0001 cmn ip, #1
b354: 1affffe5 bne b2f0 <rtems_bdbuf_remove_from_tree+0x16c>
{
/* rebalance left branch */
switch (p->avl.bal)
b358: e1d201d1 ldrsb r0, [r2, #17]
b35c: e3500000 cmp r0, #0
{
case -1:
p->avl.bal = 0;
break;
case 0:
p->avl.bal = 1;
b360: 05c26011 strbeq r6, [r2, #17]
b364: 01a01002 moveq r1, r2
}
if (p->avl.cache == -1)
{
/* rebalance left branch */
switch (p->avl.bal)
b368: 0affffed beq b324 <rtems_bdbuf_remove_from_tree+0x1a0>
b36c: e3500001 cmp r0, #1
b370: 0a000020 beq b3f8 <rtems_bdbuf_remove_from_tree+0x274>
b374: e3700001 cmn r0, #1
{
case -1:
p->avl.bal = 0;
b378: 05c24011 strbeq r4, [r2, #17]
b37c: 01a01002 moveq r1, r2
b380: 03a00001 moveq r0, #1
}
if (p->avl.cache == -1)
{
/* rebalance left branch */
switch (p->avl.bal)
b384: 1affffe4 bne b31c <rtems_bdbuf_remove_from_tree+0x198>
default:
break;
}
}
if (buf_prev > buf_stack)
b388: e1530007 cmp r3, r7
b38c: 8affffe6 bhi b32c <rtems_bdbuf_remove_from_tree+0x1a8>
q->avl.right = p;
}
}
else
{
*root = p;
b390: e58b1040 str r1, [fp, #64] ; 0x40
static void
rtems_bdbuf_remove_from_tree (rtems_bdbuf_buffer *bd)
{
if (rtems_bdbuf_avl_remove (&bdbuf_cache.tree, bd) != 0)
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);
}
b394: e28dd080 add sp, sp, #128 ; 0x80
b398: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
p->avl.bal = -1;
modified = false;
break;
case -1:
p1 = p->avl.left;
b39c: e5921008 ldr r1, [r2, #8] <== NOT EXECUTED
if (p1->avl.bal <= 0) /* simple LL-turn */
b3a0: e1d101d1 ldrsb r0, [r1, #17] <== NOT EXECUTED
b3a4: e3500000 cmp r0, #0 <== NOT EXECUTED
b3a8: da000020 ble b430 <rtems_bdbuf_remove_from_tree+0x2ac> <== NOT EXECUTED
}
p = p1;
}
else /* double LR-turn */
{
p2 = p1->avl.right;
b3ac: e591000c ldr r0, [r1, #12] <== NOT EXECUTED
p1->avl.right = p2->avl.left;
b3b0: e590c008 ldr ip, [r0, #8] <== NOT EXECUTED
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
b3b4: e1d081d1 ldrsb r8, [r0, #17] <== NOT EXECUTED
}
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
b3b8: e581c00c str ip, [r1, #12] <== NOT EXECUTED
p2->avl.left = p1;
p->avl.left = p2->avl.right;
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
b3bc: e3780001 cmn r8, #1 <== NOT EXECUTED
b3c0: 05c26011 strbeq r6, [r2, #17] <== NOT EXECUTED
b3c4: 15c24011 strbne r4, [r2, #17] <== NOT EXECUTED
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
b3c8: e590c00c ldr ip, [r0, #12] <== NOT EXECUTED
else /* double LR-turn */
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
b3cc: e5801008 str r1, [r0, #8] <== NOT EXECUTED
p->avl.left = p2->avl.right;
p2->avl.right = p;
b3d0: e580200c str r2, [r0, #12] <== NOT EXECUTED
{
p2 = p1->avl.right;
p1->avl.right = p2->avl.left;
p2->avl.left = p1;
p->avl.left = p2->avl.right;
b3d4: e582c008 str ip, [r2, #8] <== NOT EXECUTED
p2->avl.right = p;
if (p2->avl.bal == -1) p->avl.bal = 1; else p->avl.bal = 0;
if (p2->avl.bal == +1) p1->avl.bal = -1; else p1->avl.bal = 0;
b3d8: e1d021d1 ldrsb r2, [r0, #17] <== NOT EXECUTED
b3dc: e3520001 cmp r2, #1 <== NOT EXECUTED
b3e0: 05c15011 strbeq r5, [r1, #17] <== NOT EXECUTED
b3e4: 15c14011 strbne r4, [r1, #17] <== NOT EXECUTED
p = p2;
p2->avl.bal = 0;
b3e8: e5c04011 strb r4, [r0, #17] <== NOT EXECUTED
b3ec: e1a01000 mov r1, r0 <== NOT EXECUTED
b3f0: e3a00001 mov r0, #1 <== NOT EXECUTED
b3f4: eaffffca b b324 <rtems_bdbuf_remove_from_tree+0x1a0> <== NOT EXECUTED
p->avl.bal = 1;
modified = false;
break;
case +1:
p1 = p->avl.right;
b3f8: e592800c ldr r8, [r2, #12] <== NOT EXECUTED
if (p1->avl.bal >= 0) /* simple RR-turn */
b3fc: e1d8a1d1 ldrsb sl, [r8, #17] <== NOT EXECUTED
b400: e35a0000 cmp sl, #0 <== NOT EXECUTED
b404: ba000012 blt b454 <rtems_bdbuf_remove_from_tree+0x2d0> <== NOT EXECUTED
{
p->avl.right = p1->avl.left;
b408: e5981008 ldr r1, [r8, #8] <== NOT EXECUTED
p1->avl.bal = -1;
modified = false;
}
else
{
p->avl.bal = 0;
b40c: 15c24011 strbne r4, [r2, #17] <== NOT EXECUTED
case +1:
p1 = p->avl.right;
if (p1->avl.bal >= 0) /* simple RR-turn */
{
p->avl.right = p1->avl.left;
b410: e582100c str r1, [r2, #12] <== NOT EXECUTED
p1->avl.left = p;
b414: e5882008 str r2, [r8, #8] <== NOT EXECUTED
if (p1->avl.bal == 0)
{
p1->avl.bal = -1;
b418: 05c8c011 strbeq ip, [r8, #17] <== NOT EXECUTED
b41c: 01a01008 moveq r1, r8 <== NOT EXECUTED
b420: 01a0000a moveq r0, sl <== NOT EXECUTED
modified = false;
}
else
{
p->avl.bal = 0;
p1->avl.bal = 0;
b424: 11a01008 movne r1, r8 <== NOT EXECUTED
b428: 15c84011 strbne r4, [r8, #17] <== NOT EXECUTED
b42c: eaffffbc b b324 <rtems_bdbuf_remove_from_tree+0x1a0> <== NOT EXECUTED
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
b430: e591c00c ldr ip, [r1, #12] <== NOT EXECUTED
p1->avl.right = p;
if (p1->avl.bal == 0)
{
p1->avl.bal = 1;
b434: 05c16011 strbeq r6, [r1, #17] <== NOT EXECUTED
case -1:
p1 = p->avl.left;
if (p1->avl.bal <= 0) /* simple LL-turn */
{
p->avl.left = p1->avl.right;
b438: e582c008 str ip, [r2, #8] <== NOT EXECUTED
p1->avl.right = p;
b43c: e581200c str r2, [r1, #12] <== NOT EXECUTED
if (p1->avl.bal == 0)
b440: 0affffb7 beq b324 <rtems_bdbuf_remove_from_tree+0x1a0> <== NOT EXECUTED
p1->avl.bal = 1;
modified = false;
}
else
{
p->avl.bal = 0;
b444: e5c24011 strb r4, [r2, #17] <== NOT EXECUTED
p1->avl.bal = 0;
b448: e5c14011 strb r4, [r1, #17] <== NOT EXECUTED
b44c: e3a00001 mov r0, #1 <== NOT EXECUTED
b450: eaffffb3 b b324 <rtems_bdbuf_remove_from_tree+0x1a0> <== NOT EXECUTED
}
p = p1;
}
else /* double RL-turn */
{
p2 = p1->avl.left;
b454: e5981008 ldr r1, [r8, #8] <== NOT EXECUTED
p1->avl.left = p2->avl.right;
b458: e591000c ldr r0, [r1, #12] <== NOT EXECUTED
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
b45c: e1d1a1d1 ldrsb sl, [r1, #17] <== NOT EXECUTED
}
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
b460: e5880008 str r0, [r8, #8] <== NOT EXECUTED
p2->avl.right = p1;
p->avl.right = p2->avl.left;
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
b464: e35a0001 cmp sl, #1 <== NOT EXECUTED
b468: 05c2c011 strbeq ip, [r2, #17] <== NOT EXECUTED
b46c: 15c24011 strbne r4, [r2, #17] <== NOT EXECUTED
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
b470: e5910008 ldr r0, [r1, #8] <== NOT EXECUTED
else /* double RL-turn */
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
b474: e581800c str r8, [r1, #12] <== NOT EXECUTED
p->avl.right = p2->avl.left;
p2->avl.left = p;
b478: e5812008 str r2, [r1, #8] <== NOT EXECUTED
{
p2 = p1->avl.left;
p1->avl.left = p2->avl.right;
p2->avl.right = p1;
p->avl.right = p2->avl.left;
b47c: e582000c str r0, [r2, #12] <== NOT EXECUTED
p2->avl.left = p;
if (p2->avl.bal == +1) p->avl.bal = -1; else p->avl.bal = 0;
if (p2->avl.bal == -1) p1->avl.bal = 1; else p1->avl.bal = 0;
b480: e1d121d1 ldrsb r2, [r1, #17] <== NOT EXECUTED
b484: e3720001 cmn r2, #1 <== NOT EXECUTED
b488: 05c86011 strbeq r6, [r8, #17] <== NOT EXECUTED
b48c: 15c84011 strbne r4, [r8, #17] <== NOT EXECUTED
b490: eaffffec b b448 <rtems_bdbuf_remove_from_tree+0x2c4> <== NOT EXECUTED
}
/* at this moment q - is a node to delete, p is q's parent */
if (q->avl.right == NULL)
{
r = q->avl.left;
b494: e5942008 ldr r2, [r4, #8]
if (r != NULL)
b498: e3520000 cmp r2, #0
{
r->avl.bal = 0;
b49c: 13a03000 movne r3, #0
b4a0: 15c23011 strbne r3, [r2, #17]
b4a4: e1a03001 mov r3, r1
b4a8: eaffff83 b b2bc <rtems_bdbuf_remove_from_tree+0x138>
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
r->avl.bal = q->avl.bal;
b4ac: e5d40011 ldrb r0, [r4, #17]
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
b4b0: e594c008 ldr ip, [r4, #8]
r->avl.bal = q->avl.bal;
b4b4: e5c20011 strb r0, [r2, #17]
r->avl.cache = 1;
b4b8: e3a00001 mov r0, #1
r = q->avl.right;
if (r->avl.left == NULL)
{
r->avl.left = q->avl.left;
b4bc: e582c008 str ip, [r2, #8]
r->avl.bal = q->avl.bal;
r->avl.cache = 1;
b4c0: e5c20010 strb r0, [r2, #16]
*buf_prev++ = q = r;
b4c4: e5812000 str r2, [r1]
b4c8: eaffff7b b b2bc <rtems_bdbuf_remove_from_tree+0x138>
0000b4d0 <rtems_bdbuf_remove_from_tree_and_lru_list>:
}
static void
rtems_bdbuf_remove_from_tree_and_lru_list (rtems_bdbuf_buffer *bd)
{
switch (bd->state)
b4d0: e5903024 ldr r3, [r0, #36] ; 0x24
b4d4: e3530000 cmp r3, #0
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_TREE_RM);
}
static void
rtems_bdbuf_remove_from_tree_and_lru_list (rtems_bdbuf_buffer *bd)
{
b4d8: e92d4010 push {r4, lr}
b4dc: e1a04000 mov r4, r0
switch (bd->state)
b4e0: 0a000007 beq b504 <rtems_bdbuf_remove_from_tree_and_lru_list+0x34>
b4e4: e3530002 cmp r3, #2
b4e8: 0a000004 beq b500 <rtems_bdbuf_remove_from_tree_and_lru_list+0x30>
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10);
b4ec: e5900024 ldr r0, [r0, #36] ; 0x24 <== NOT EXECUTED
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
b4f0: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
b4f4: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
b4f8: e3800008 orr r0, r0, #8 <== NOT EXECUTED
b4fc: ebffeefd bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
switch (bd->state)
{
case RTEMS_BDBUF_STATE_FREE:
break;
case RTEMS_BDBUF_STATE_CACHED:
rtems_bdbuf_remove_from_tree (bd);
b500: ebffff1f bl b184 <rtems_bdbuf_remove_from_tree>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
b504: e1a00004 mov r0, r4
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_10);
}
rtems_chain_extract (&bd->link);
}
b508: e8bd4010 pop {r4, lr}
b50c: eafff030 b 75d4 <_Chain_Extract>
0000ac48 <rtems_bdbuf_restore_preemption>:
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
ac48: e52de004 push {lr} ; (str lr, [sp, #-4]!)
ac4c: e24dd004 sub sp, sp, #4
ac50: e28d2004 add r2, sp, #4
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode);
ac54: e3a01801 mov r1, #65536 ; 0x10000
return prev_mode;
}
static void
rtems_bdbuf_restore_preemption (rtems_mode prev_mode)
{
ac58: e5220004 str r0, [r2, #-4]!
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode);
ac5c: e2411001 sub r1, r1, #1
ac60: e1a0200d mov r2, sp
ac64: eb00123d bl f560 <rtems_task_mode>
if (sc != RTEMS_SUCCESSFUL)
ac68: e3500000 cmp r0, #0
ac6c: 1a000001 bne ac78 <rtems_bdbuf_restore_preemption+0x30>
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_RST);
}
ac70: e28dd004 add sp, sp, #4
ac74: e8bd8000 pop {pc}
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
sc = rtems_task_mode (prev_mode, RTEMS_ALL_MODE_MASKS, &prev_mode);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_PREEMPT_RST);
ac78: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
ac7c: e2800011 add r0, r0, #17 <== NOT EXECUTED
ac80: ebfff11c bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000bbe8 <rtems_bdbuf_swapout_task>:
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
bbe8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_bdbuf_swapout_transfer transfer; uint32_t period_in_ticks; const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
bbec: e59f4354 ldr r4, [pc, #852] ; bf48 <rtems_bdbuf_swapout_task+0x360>
* not this.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_task (rtems_task_argument arg)
{
bbf0: e24dd038 sub sp, sp, #56 ; 0x38
rtems_bdbuf_swapout_transfer transfer; uint32_t period_in_ticks; const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
bbf4: e594900c ldr r9, [r4, #12]
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
bbf8: ebfffd4c bl b130 <rtems_bdbuf_swapout_writereq_alloc>
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
bbfc: e59f2348 ldr r2, [pc, #840] ; bf4c <rtems_bdbuf_swapout_task+0x364>
bc00: e0893109 add r3, r9, r9, lsl #2
bc04: e0833103 add r3, r3, r3, lsl #2
bc08: e592100c ldr r1, [r2, #12]
bc0c: e0833103 add r3, r3, r3, lsl #2
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
bc10: e28d2014 add r2, sp, #20
the_chain->permanent_null = NULL;
bc14: e3a06000 mov r6, #0
rtems_bdbuf_swapout_transfer transfer;
uint32_t period_in_ticks;
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
bc18: e58d002c str r0, [sp, #44] ; 0x2c
rtems_chain_initialize_empty (&transfer.bds); transfer.dev = BDBUF_INVALID_DEV;
bc1c: e3e07000 mvn r7, #0
transfer.syncing = false;
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
bc20: e1a00183 lsl r0, r3, #3
const uint32_t period_in_msecs = bdbuf_config.swapout_period;;
uint32_t timer_delta;
transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&transfer.bds);
transfer.dev = BDBUF_INVALID_DEV;
bc24: e3e08000 mvn r8, #0
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
bc28: e2823004 add r3, r2, #4
bc2c: e58d3014 str r3, [sp, #20]
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
bc30: e58d201c str r2, [sp, #28]
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
bc34: e58d6018 str r6, [sp, #24]
bc38: e58d7020 str r7, [sp, #32]
bc3c: e58d8024 str r8, [sp, #36] ; 0x24
transfer.syncing = false;
bc40: e5cd6028 strb r6, [sp, #40] ; 0x28
/*
* Localise the period.
*/
period_in_ticks = RTEMS_MICROSECONDS_TO_TICKS (period_in_msecs * 1000);
bc44: eb003e88 bl 1b66c <__aeabi_uidiv>
bc48: e58d000c str r0, [sp, #12]
rtems_bdbuf_swapout_workers_open (void)
{
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
bc4c: ebfffa9f bl a6d0 <rtems_bdbuf_lock_cache>
for (w = 0; w < bdbuf_config.swapout_workers; w++)
bc50: e5943014 ldr r3, [r4, #20]
bc54: e1530006 cmp r3, r6
bc58: e58d3008 str r3, [sp, #8]
bc5c: 059f52ec ldreq r5, [pc, #748] ; bf50 <rtems_bdbuf_swapout_task+0x368>
bc60: 0a000032 beq bd30 <rtems_bdbuf_swapout_task+0x148>
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
bc64: e1a02007 mov r2, r7 <== NOT EXECUTED
bc68: e1a03008 mov r3, r8 <== NOT EXECUTED
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
(bdbuf_config.swapout_priority ?
bc6c: e5948008 ldr r8, [r4, #8] <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
bc70: e58d9010 str r9, [sp, #16] <== NOT EXECUTED
bc74: e1a0a003 mov sl, r3 <== NOT EXECUTED
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
bc78: e3a0b001 mov fp, #1 <== NOT EXECUTED
bc7c: e1a07006 mov r7, r6 <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
bc80: e1a09002 mov r9, r2 <== NOT EXECUTED
for (w = 0; w < bdbuf_config.swapout_workers; w++)
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
bc84: e3a00030 mov r0, #48 ; 0x30 <== NOT EXECUTED
bc88: ebffddf5 bl 3464 <malloc> <== NOT EXECUTED
if (!worker)
bc8c: e2504000 subs r4, r0, #0 <== NOT EXECUTED
bc90: 0a0000a9 beq bf3c <rtems_bdbuf_swapout_task+0x354> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
bc94: e59f52b4 ldr r5, [pc, #692] ; bf50 <rtems_bdbuf_swapout_task+0x368><== NOT EXECUTED
bc98: e1a01004 mov r1, r4 <== NOT EXECUTED
bc9c: e2850008 add r0, r5, #8 <== NOT EXECUTED
bca0: ebffee40 bl 75a8 <_Chain_Append> <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
bca4: e5c4b00c strb fp, [r4, #12] <== NOT EXECUTED
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
bca8: ebfffd20 bl b130 <rtems_bdbuf_swapout_writereq_alloc> <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
bcac: e2863061 add r3, r6, #97 ; 0x61 <== NOT EXECUTED
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
bcb0: e5840028 str r0, [r4, #40] ; 0x28 <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
bcb4: e3830442 orr r0, r3, #1107296256 ; 0x42000000 <== NOT EXECUTED
bcb8: e3580000 cmp r8, #0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
bcbc: e2842014 add r2, r4, #20 <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
bcc0: e2843010 add r3, r4, #16 <== NOT EXECUTED
bcc4: e3800711 orr r0, r0, #4456448 ; 0x440000 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
bcc8: e5842010 str r2, [r4, #16] <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
bccc: e5843018 str r3, [r4, #24] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
bcd0: e5847014 str r7, [r4, #20] <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
worker->enabled = true;
worker->transfer.write_req = rtems_bdbuf_swapout_writereq_alloc ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
bcd4: e584901c str r9, [r4, #28] <== NOT EXECUTED
bcd8: e584a020 str sl, [r4, #32] <== NOT EXECUTED
sc = rtems_task_create (rtems_build_name('B', 'D', 'o', 'a' + w),
bcdc: 11a01008 movne r1, r8 <== NOT EXECUTED
bce0: 03a0100f moveq r1, #15 <== NOT EXECUTED
bce4: e284c008 add ip, r4, #8 <== NOT EXECUTED
bce8: e3800c6f orr r0, r0, #28416 ; 0x6f00 <== NOT EXECUTED
bcec: e3a02a02 mov r2, #8192 ; 0x2000 <== NOT EXECUTED
bcf0: e3a03b01 mov r3, #1024 ; 0x400 <== NOT EXECUTED
bcf4: e88d1080 stm sp, {r7, ip} <== NOT EXECUTED
bcf8: ebffebf8 bl 6ce0 <rtems_task_create> <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_TASK_PRIORITY_DEFAULT),
SWAPOUT_TASK_STACK_SIZE,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
bcfc: e3500000 cmp r0, #0 <== NOT EXECUTED
bd00: 1a00008a bne bf30 <rtems_bdbuf_swapout_task+0x348> <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
sc = rtems_task_start (worker->id,
bd04: e1a02004 mov r2, r4 <== NOT EXECUTED
bd08: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
bd0c: e59f1240 ldr r1, [pc, #576] ; bf54 <rtems_bdbuf_swapout_task+0x36c><== NOT EXECUTED
bd10: ebffec84 bl 6f28 <rtems_task_start> <== NOT EXECUTED
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
bd14: e3500000 cmp r0, #0 <== NOT EXECUTED
bd18: 1a000081 bne bf24 <rtems_bdbuf_swapout_task+0x33c> <== NOT EXECUTED
rtems_status_code sc;
size_t w;
rtems_bdbuf_lock_cache ();
for (w = 0; w < bdbuf_config.swapout_workers; w++)
bd1c: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
bd20: e2866001 add r6, r6, #1 <== NOT EXECUTED
bd24: e1560002 cmp r6, r2 <== NOT EXECUTED
bd28: 3affffd5 bcc bc84 <rtems_bdbuf_swapout_task+0x9c> <== NOT EXECUTED
bd2c: e59d9010 ldr r9, [sp, #16] <== NOT EXECUTED
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
}
rtems_bdbuf_unlock_cache ();
bd30: ebfffae1 bl a8bc <rtems_bdbuf_unlock_cache>
* here. We do not know the worker is the last in a sequence of sync writes * until after we have it running so we do not know to tell it to release the * lock. The simplest solution is to get the main swap out task perform all * sync operations. */ if (bdbuf_cache.sync_active)
bd34: e3a0b000 mov fp, #0
/*
* Create the worker threads.
*/
rtems_bdbuf_swapout_workers_open ();
while (bdbuf_cache.swapout_enabled)
bd38: e5d53004 ldrb r3, [r5, #4]
bd3c: e21330ff ands r3, r3, #255 ; 0xff
bd40: e59f4208 ldr r4, [pc, #520] ; bf50 <rtems_bdbuf_swapout_task+0x368>
bd44: 0a00005f beq bec8 <rtems_bdbuf_swapout_task+0x2e0>
bd48: e3a0a001 mov sl, #1
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
bd4c: ebfffa5f bl a6d0 <rtems_bdbuf_lock_cache>
* here. We do not know the worker is the last in a sequence of sync writes * until after we have it running so we do not know to tell it to release the * lock. The simplest solution is to get the main swap out task perform all * sync operations. */ if (bdbuf_cache.sync_active)
bd50: e5d53030 ldrb r3, [r5, #48] ; 0x30
bd54: e3530000 cmp r3, #0
bd58: 13a08000 movne r8, #0
bd5c: 128d4014 addne r4, sp, #20
bd60: 0a00004f beq bea4 <rtems_bdbuf_swapout_task+0x2bc>
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
transfer->syncing = bdbuf_cache.sync_active;
bd64: e5d53030 ldrb r3, [r5, #48] ; 0x30
bd68: e5c43014 strb r3, [r4, #20]
/* * When the sync is for a device limit the sync to that device. If the sync * is for a buffer handle process the devices in the order on the sync * list. This means the dev is BDBUF_INVALID_DEV. */ if (bdbuf_cache.sync_active)
bd6c: e5d53030 ldrb r3, [r5, #48] ; 0x30
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
bd70: e2847004 add r7, r4, #4
bd74: e3530000 cmp r3, #0
if (worker)
transfer = &worker->transfer;
}
rtems_chain_initialize_empty (&transfer->bds);
transfer->dev = BDBUF_INVALID_DEV;
bd78: e3e01000 mvn r1, #0
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
bd7c: e3a03000 mov r3, #0
bd80: e3e02000 mvn r2, #0
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
bd84: e5847000 str r7, [r4]
the_chain->permanent_null = NULL;
bd88: e9840018 stmib r4, {r3, r4}
bd8c: e584100c str r1, [r4, #12]
bd90: e5842010 str r2, [r4, #16]
* When the sync is for a device limit the sync to that device. If the sync
* is for a buffer handle process the devices in the order on the sync
* list. This means the dev is BDBUF_INVALID_DEV.
*/
if (bdbuf_cache.sync_active)
transfer->dev = bdbuf_cache.sync_device;
bd94: 159f11b4 ldrne r1, [pc, #436] ; bf50 <rtems_bdbuf_swapout_task+0x368>
bd98: 12813038 addne r3, r1, #56 ; 0x38
bd9c: 1893000c ldmne r3, {r2, r3}
bda0: 1584200c strne r2, [r4, #12]
bda4: 15843010 strne r3, [r4, #16]
/*
* If we have any buffers in the sync queue move them to the modified
* list. The first sync buffer will select the device we use.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
bda8: e284600c add r6, r4, #12
bdac: e1a02004 mov r2, r4
bdb0: e1a00006 mov r0, r6
bdb4: e59f119c ldr r1, [pc, #412] ; bf58 <rtems_bdbuf_swapout_task+0x370>
bdb8: e3a03001 mov r3, #1
bdbc: e58db000 str fp, [sp]
bdc0: e58d9004 str r9, [sp, #4]
bdc4: ebfffa52 bl a714 <rtems_bdbuf_swapout_modified_processing>
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
&bdbuf_cache.modified,
&transfer->bds,
bdbuf_cache.sync_active,
bdc8: e5d53030 ldrb r3, [r5, #48] ; 0x30
timer_delta);
/*
* Process the cache's modified list.
*/
rtems_bdbuf_swapout_modified_processing (&transfer->dev,
bdcc: e1a02004 mov r2, r4
bdd0: e1a00006 mov r0, r6
bdd4: e59f1180 ldr r1, [pc, #384] ; bf5c <rtems_bdbuf_swapout_task+0x374>
bdd8: e58da000 str sl, [sp]
bddc: e58d9004 str r9, [sp, #4]
bde0: ebfffa4b bl a714 <rtems_bdbuf_swapout_modified_processing>
/* * We have all the buffers that have been modified for this device so the * cache can be unlocked because the state of each buffer has been set to * TRANSFER. */ rtems_bdbuf_unlock_cache ();
bde4: ebfffab4 bl a8bc <rtems_bdbuf_unlock_cache>
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
bde8: e5943000 ldr r3, [r4]
bdec: e1570003 cmp r7, r3
bdf0: 01a0400b moveq r4, fp
bdf4: 0a000007 beq be18 <rtems_bdbuf_swapout_task+0x230>
{
if (worker)
bdf8: e3580000 cmp r8, #0
bdfc: 0a00002e beq bebc <rtems_bdbuf_swapout_task+0x2d4>
{
rtems_status_code sc = rtems_event_send (worker->id,
be00: e5980008 ldr r0, [r8, #8] <== NOT EXECUTED
be04: e3a01004 mov r1, #4 <== NOT EXECUTED
be08: ebffea1c bl 6680 <rtems_event_send> <== NOT EXECUTED
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
be0c: e3500000 cmp r0, #0 <== NOT EXECUTED
be10: 1a000040 bne bf18 <rtems_bdbuf_swapout_task+0x330> <== NOT EXECUTED
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
}
else
{
rtems_bdbuf_swapout_write (transfer);
be14: e3a04001 mov r4, #1
}
transfered_buffers = true;
}
if (bdbuf_cache.sync_active && !transfered_buffers)
be18: e5d5a030 ldrb sl, [r5, #48] ; 0x30
be1c: e21aa0ff ands sl, sl, #255 ; 0xff
be20: 0a000017 beq be84 <rtems_bdbuf_swapout_task+0x29c>
be24: e3540000 cmp r4, #0
be28: e3a0a000 mov sl, #0
be2c: 1affffc6 bne bd4c <rtems_bdbuf_swapout_task+0x164>
{
rtems_id sync_requester;
rtems_bdbuf_lock_cache ();
be30: ebfffa26 bl a6d0 <rtems_bdbuf_lock_cache>
sync_requester = bdbuf_cache.sync_requester;
be34: e59f2114 ldr r2, [pc, #276] ; bf50 <rtems_bdbuf_swapout_task+0x368>
be38: e5926034 ldr r6, [r2, #52] ; 0x34
bdbuf_cache.sync_active = false;
be3c: e5c24030 strb r4, [r2, #48] ; 0x30
bdbuf_cache.sync_requester = 0;
be40: e5824034 str r4, [r2, #52] ; 0x34
rtems_bdbuf_unlock_cache ();
be44: ebfffa9c bl a8bc <rtems_bdbuf_unlock_cache>
if (sync_requester)
be48: e156000a cmp r6, sl
rtems_event_send (sync_requester, RTEMS_BDBUF_TRANSFER_SYNC);
be4c: 11a00006 movne r0, r6
be50: 13a01002 movne r1, #2
be54: 1bffea09 blne 6680 <rtems_event_send>
*/
update_timers = false;
}
while (transfered_buffers);
sc = rtems_event_receive (RTEMS_BDBUF_SWAPOUT_SYNC,
be58: e3a00004 mov r0, #4
be5c: e3a01000 mov r1, #0
be60: e59d200c ldr r2, [sp, #12]
be64: e28d3034 add r3, sp, #52 ; 0x34
be68: ebffe9a6 bl 6508 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
period_in_ticks,
&out);
if ((sc != RTEMS_SUCCESSFUL) && (sc != RTEMS_TIMEOUT))
be6c: e3500006 cmp r0, #6
be70: 13500000 cmpne r0, #0
be74: 0affffaf beq bd38 <rtems_bdbuf_swapout_task+0x150>
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
be78: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
be7c: e2800018 add r0, r0, #24 <== NOT EXECUTED
be80: ebffec9c bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
/*
* Extact all the buffers we find for a specific device. The device is
* the first one we find on a modified list. Process the sync queue of
* buffers first.
*/
if (rtems_bdbuf_swapout_processing (timer_delta,
be84: e3540000 cmp r4, #0
be88: 0afffff2 beq be58 <rtems_bdbuf_swapout_task+0x270>
rtems_bdbuf_swapout_transfer* transfer)
{
rtems_bdbuf_swapout_worker* worker;
bool transfered_buffers = false;
rtems_bdbuf_lock_cache ();
be8c: ebfffa0f bl a6d0 <rtems_bdbuf_lock_cache>
* here. We do not know the worker is the last in a sequence of sync writes * until after we have it running so we do not know to tell it to release the * lock. The simplest solution is to get the main swap out task perform all * sync operations. */ if (bdbuf_cache.sync_active)
be90: e5d53030 ldrb r3, [r5, #48] ; 0x30
be94: e3530000 cmp r3, #0
be98: 13a08000 movne r8, #0
be9c: 128d4014 addne r4, sp, #20
bea0: 1affffaf bne bd64 <rtems_bdbuf_swapout_task+0x17c>
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
bea4: e59f00b4 ldr r0, [pc, #180] ; bf60 <rtems_bdbuf_swapout_task+0x378>
bea8: ebffedd2 bl 75f8 <_Chain_Get>
worker = NULL;
else
{
worker = (rtems_bdbuf_swapout_worker*)
rtems_chain_get (&bdbuf_cache.swapout_workers);
if (worker)
beac: e2508000 subs r8, r0, #0
beb0: 028d4014 addeq r4, sp, #20
transfer = &worker->transfer;
beb4: 12884010 addne r4, r8, #16
beb8: eaffffa9 b bd64 <rtems_bdbuf_swapout_task+0x17c>
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
}
else
{
rtems_bdbuf_swapout_write (transfer);
bebc: e1a00004 mov r0, r4
bec0: ebfffedd bl ba3c <rtems_bdbuf_swapout_write>
bec4: eaffffd2 b be14 <rtems_bdbuf_swapout_task+0x22c>
bec8: e1a06003 mov r6, r3 <== NOT EXECUTED
static void
rtems_bdbuf_swapout_workers_close (void)
{
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
becc: ebfff9ff bl a6d0 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return the_chain->first;
bed0: e5945008 ldr r5, [r4, #8] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
bed4: e284400c add r4, r4, #12 <== NOT EXECUTED
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
bed8: e1550004 cmp r5, r4 <== NOT EXECUTED
bedc: 0a000006 beq befc <rtems_bdbuf_swapout_task+0x314> <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) node;
worker->enabled = false;
bee0: e5c5600c strb r6, [r5, #12] <== NOT EXECUTED
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
bee4: e5950008 ldr r0, [r5, #8] <== NOT EXECUTED
bee8: e3a01004 mov r1, #4 <== NOT EXECUTED
beec: ebffe9e3 bl 6680 <rtems_event_send> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
bef0: e5955000 ldr r5, [r5] <== NOT EXECUTED
rtems_chain_node* node;
rtems_bdbuf_lock_cache ();
node = rtems_chain_first (&bdbuf_cache.swapout_workers);
while (!rtems_chain_is_tail (&bdbuf_cache.swapout_workers, node))
bef4: e1550004 cmp r5, r4 <== NOT EXECUTED
bef8: 1afffff8 bne bee0 <rtems_bdbuf_swapout_task+0x2f8> <== NOT EXECUTED
worker->enabled = false;
rtems_event_send (worker->id, RTEMS_BDBUF_SWAPOUT_SYNC);
node = rtems_chain_next (node);
}
rtems_bdbuf_unlock_cache ();
befc: ebfffa6e bl a8bc <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
rtems_fatal_error_occurred (BLKDEV_FATAL_BDBUF_SWAPOUT_RE);
}
rtems_bdbuf_swapout_workers_close ();
free (transfer.write_req);
bf00: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED
bf04: ebffdc7d bl 3100 <free> <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
bf08: e3a00000 mov r0, #0 <== NOT EXECUTED
bf0c: ebffebc1 bl 6e18 <rtems_task_delete> <== NOT EXECUTED
}
bf10: e28dd038 add sp, sp, #56 ; 0x38 <== NOT EXECUTED
bf14: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (worker)
{
rtems_status_code sc = rtems_event_send (worker->id,
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
bf18: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
bf1c: e2800014 add r0, r0, #20 <== NOT EXECUTED
bf20: ebffec74 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
sc = rtems_task_start (worker->id,
rtems_bdbuf_swapout_worker_task,
(rtems_task_argument) worker);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_START);
bf24: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
bf28: e2800017 add r0, r0, #23 <== NOT EXECUTED
bf2c: ebffec71 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
SWAPOUT_TASK_STACK_SIZE,
RTEMS_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR,
RTEMS_LOCAL | RTEMS_NO_FLOATING_POINT,
&worker->id);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WK_CREATE);
bf30: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
bf34: e2800016 add r0, r0, #22 <== NOT EXECUTED
bf38: ebffec6e bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker;
worker = malloc (sizeof (rtems_bdbuf_swapout_worker));
if (!worker)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
bf3c: e2800442 add r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
bf40: e2800015 add r0, r0, #21 <== NOT EXECUTED
bf44: ebffec6b bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000bf64 <rtems_bdbuf_swapout_worker_task>:
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
bf64: e5d0300c ldrb r3, [r0, #12] <== NOT EXECUTED
bf68: e3530000 cmp r3, #0 <== NOT EXECUTED
* @param arg A pointer to the worker thread's private data.
* @return rtems_task Not used.
*/
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
bf6c: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
bf70: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
bf74: 0a000015 beq bfd0 <rtems_bdbuf_swapout_worker_task+0x6c> <== NOT EXECUTED
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
rtems_bdbuf_swapout_write (&worker->transfer);
bf78: e2805010 add r5, r0, #16 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
bf7c: e280a014 add sl, r0, #20 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
bf80: e3a08000 mov r8, #0 <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
bf84: e3e06000 mvn r6, #0 <== NOT EXECUTED
bf88: e3e07000 mvn r7, #0 <== NOT EXECUTED
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
{
rtems_bdbuf_wait_for_event (RTEMS_BDBUF_SWAPOUT_SYNC);
bf8c: e3a00004 mov r0, #4 <== NOT EXECUTED
bf90: ebfffae4 bl ab28 <rtems_bdbuf_wait_for_event> <== NOT EXECUTED
rtems_bdbuf_swapout_write (&worker->transfer);
bf94: e1a00005 mov r0, r5 <== NOT EXECUTED
bf98: ebfffea7 bl ba3c <rtems_bdbuf_swapout_write> <== NOT EXECUTED
rtems_bdbuf_lock_cache ();
bf9c: ebfff9cb bl a6d0 <rtems_bdbuf_lock_cache> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
bfa0: e59f0044 ldr r0, [pc, #68] ; bfec <rtems_bdbuf_swapout_worker_task+0x88><== NOT EXECUTED
bfa4: e1a01004 mov r1, r4 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
bfa8: e584a010 str sl, [r4, #16] <== NOT EXECUTED
the_chain->permanent_null = NULL;
bfac: e5848014 str r8, [r4, #20] <== NOT EXECUTED
the_chain->last = _Chain_Head(the_chain);
bfb0: e5845018 str r5, [r4, #24] <== NOT EXECUTED
rtems_chain_initialize_empty (&worker->transfer.bds);
worker->transfer.dev = BDBUF_INVALID_DEV;
bfb4: e584601c str r6, [r4, #28] <== NOT EXECUTED
bfb8: e5847020 str r7, [r4, #32] <== NOT EXECUTED
bfbc: ebffed79 bl 75a8 <_Chain_Append> <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
bfc0: ebfffa3d bl a8bc <rtems_bdbuf_unlock_cache> <== NOT EXECUTED
static rtems_task
rtems_bdbuf_swapout_worker_task (rtems_task_argument arg)
{
rtems_bdbuf_swapout_worker* worker = (rtems_bdbuf_swapout_worker*) arg;
while (worker->enabled)
bfc4: e5d4300c ldrb r3, [r4, #12] <== NOT EXECUTED
bfc8: e3530000 cmp r3, #0 <== NOT EXECUTED
bfcc: 1affffee bne bf8c <rtems_bdbuf_swapout_worker_task+0x28> <== NOT EXECUTED
rtems_chain_append (&bdbuf_cache.swapout_workers, &worker->link);
rtems_bdbuf_unlock_cache ();
}
free (worker->transfer.write_req);
bfd0: e5940028 ldr r0, [r4, #40] ; 0x28 <== NOT EXECUTED
bfd4: ebffdc49 bl 3100 <free> <== NOT EXECUTED
free (worker);
bfd8: e1a00004 mov r0, r4 <== NOT EXECUTED
bfdc: ebffdc47 bl 3100 <free> <== NOT EXECUTED
rtems_task_delete (RTEMS_SELF);
bfe0: e3a00000 mov r0, #0 <== NOT EXECUTED
}
bfe4: e8bd45f0 pop {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
}
free (worker->transfer.write_req);
free (worker);
rtems_task_delete (RTEMS_SELF);
bfe8: eaffeb8a b 6e18 <rtems_task_delete> <== NOT EXECUTED
0000ba3c <rtems_bdbuf_swapout_write>:
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
ba3c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dev);
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
ba40: e5903000 ldr r3, [r0]
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
ba44: e2807004 add r7, r0, #4
ba48: e1530007 cmp r3, r7
*
* @param transfer The transfer transaction.
*/
static void
rtems_bdbuf_swapout_write (rtems_bdbuf_swapout_transfer* transfer)
{
ba4c: e24dd004 sub sp, sp, #4
ba50: e1a04000 mov r4, r0
printf ("bdbuf:swapout transfer: %08x\n", (unsigned) transfer->dev);
/*
* If there are buffers to transfer to the media transfer them.
*/
if (!rtems_chain_is_empty (&transfer->bds))
ba54: 0a00005b beq bbc8 <rtems_bdbuf_swapout_write+0x18c>
/*
* Obtain the disk device. The cache's mutex has been released to avoid a
* dead lock.
*/
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
ba58: e280100c add r1, r0, #12
ba5c: e8910003 ldm r1, {r0, r1}
ba60: ebffd98a bl 2090 <rtems_disk_obtain>
if (dd == NULL)
ba64: e2505000 subs r5, r0, #0
ba68: 059f3170 ldreq r3, [pc, #368] ; bbe0 <rtems_bdbuf_swapout_write+0x1a4>
dd = &null_disk;
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
ba6c: e59f8170 ldr r8, [pc, #368] ; bbe4 <rtems_bdbuf_swapout_write+0x1a8>
ba70: 159f3168 ldrne r3, [pc, #360] ; bbe0 <rtems_bdbuf_swapout_write+0x1a4>
* Obtain the disk device. The cache's mutex has been released to avoid a
* dead lock.
*/
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
if (dd == NULL)
ba74: 01a05003 moveq r5, r3
dd = &null_disk;
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
ba78: e5950020 ldr r0, [r5, #32]
ba7c: e5981020 ldr r1, [r8, #32]
ba80: 158d3000 strne r3, [sp]
* Obtain the disk device. The cache's mutex has been released to avoid a
* dead lock.
*/
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
if (dd == NULL)
ba84: 058d3000 streq r3, [sp]
dd = &null_disk;
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
ba88: eb003ef7 bl 1b66c <__aeabi_uidiv>
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
ba8c: e5943018 ldr r3, [r4, #24]
transfer->write_req->bufnum = 0;
ba90: e3a02000 mov r2, #0
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
ba94: e3a0a00c mov sl, #12
transfer->write_req->bufnum = 0;
ba98: e5832010 str r2, [r3, #16]
* should be possible to make this change with little effect in this
* code. The array that is passed is broken in design and should be
* removed. Merging members of a struct into the first member is
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
ba9c: e583a00c str sl, [r3, #12]
* Perform the transfer if there are no more buffers, or the transfer
* size has reached the configured max. value.
*/
if (rtems_chain_is_empty (&transfer->bds) ||
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
baa0: e5988004 ldr r8, [r8, #4]
rtems_disk_device *dd = rtems_disk_obtain (transfer->dev);
if (dd == NULL)
dd = &null_disk;
bufs_per_bd = dd->block_size / bdbuf_config.buffer_min;
baa4: e1a0b000 mov fp, r0
* Perform the transfer if there are no more buffers, or the transfer
* size has reached the configured max. value.
*/
if (rtems_chain_is_empty (&transfer->bds) ||
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
baa8: e1a06002 mov r6, r2
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
buf->length = dd->block_size;
buf->buffer = bd->buffer;
last_block = bd->block;
baac: e1a09002 mov r9, r2
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
bab0: e1a00004 mov r0, r4
bab4: ebffeecf bl 75f8 <_Chain_Get>
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
bab8: e2502000 subs r2, r0, #0
babc: 0a000020 beq bb44 <rtems_bdbuf_swapout_write+0x108>
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
bac0: e5953008 ldr r3, [r5, #8]
bac4: e593300c ldr r3, [r3, #12]
bac8: e3130001 tst r3, #1
bacc: 0a00002a beq bb7c <rtems_bdbuf_swapout_write+0x140>
transfer->write_req->bufnum &&
bad0: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED
bad4: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
bad8: e3530000 cmp r3, #0 <== NOT EXECUTED
badc: 0a000028 beq bb84 <rtems_bdbuf_swapout_write+0x148> <== NOT EXECUTED
transfer->write_req->bufnum &&
(bd->block != (last_block + bufs_per_bd)))
bae0: e592c01c ldr ip, [r2, #28] <== NOT EXECUTED
bae4: e086000b add r0, r6, fp <== NOT EXECUTED
bae8: e15c0000 cmp ip, r0 <== NOT EXECUTED
baec: 0a000024 beq bb84 <rtems_bdbuf_swapout_write+0x148> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
baf0: e1a01002 mov r1, r2 <== NOT EXECUTED
baf4: e1a00004 mov r0, r4 <== NOT EXECUTED
baf8: eb000fc6 bl fa18 <_Chain_Insert> <== NOT EXECUTED
bafc: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED
bb00: e3a02001 mov r2, #1 <== NOT EXECUTED
/*
* Perform the transfer if there are no more buffers, or the transfer
* size has reached the configured max. value.
*/
if (rtems_chain_is_empty (&transfer->bds) ||
bb04: e5943000 ldr r3, [r4]
bb08: e1570003 cmp r7, r3
bb0c: 0a000002 beq bb1c <rtems_bdbuf_swapout_write+0xe0>
bb10: e5913010 ldr r3, [r1, #16]
bb14: e1530008 cmp r3, r8
bb18: 3a000027 bcc bbbc <rtems_bdbuf_swapout_write+0x180>
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
bb1c: e3a02000 mov r2, #0
bb20: e1a00005 mov r0, r5
bb24: ebffff6f bl b8e8 <rtems_bdbuf_execute_transfer_request>
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
bb28: e5943018 ldr r3, [r4, #24]
bb2c: e1a00004 mov r0, r4
transfer->write_req->bufnum = 0;
bb30: e5839010 str r9, [r3, #16]
if (write)
{
rtems_bdbuf_execute_transfer_request (dd, transfer->write_req, false);
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
bb34: e583a00c str sl, [r3, #12]
bb38: ebffeeae bl 75f8 <_Chain_Get>
* trouble waiting to happen.
*/
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
while ((node = rtems_chain_get(&transfer->bds)) != NULL)
bb3c: e2502000 subs r2, r0, #0
bb40: 1affffde bne bac0 <rtems_bdbuf_swapout_write+0x84>
transfer->write_req->status = RTEMS_RESOURCE_IN_USE;
transfer->write_req->bufnum = 0;
}
}
if (dd != &null_disk)
bb44: e59d3000 ldr r3, [sp]
bb48: e1550003 cmp r5, r3
bb4c: 0a00001d beq bbc8 <rtems_bdbuf_swapout_write+0x18c>
{
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
bb50: e5d43014 ldrb r3, [r4, #20]
bb54: e3530000 cmp r3, #0
bb58: 0a000003 beq bb6c <rtems_bdbuf_swapout_write+0x130>
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
bb5c: e5950008 ldr r0, [r5, #8]
{
/*
* If sync'ing and the deivce is capability of handling a sync IO control
* call perform the call.
*/
if (transfer->syncing &&
bb60: e590300c ldr r3, [r0, #12]
bb64: e3130002 tst r3, #2
bb68: 1a000018 bne bbd0 <rtems_bdbuf_swapout_write+0x194>
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
/* How should the error be handled ? */
}
rtems_disk_release (dd);
bb6c: e1a00005 mov r0, r5
}
}
}
bb70: e28dd004 add sp, sp, #4
bb74: e8bd4ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, lr}
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
/* How should the error be handled ? */
}
rtems_disk_release (dd);
bb78: eaffd9d8 b 22e0 <rtems_disk_release>
printf ("bdbuf:swapout write: bd:%" PRIu32 ", bufnum:%" PRIu32 " mode:%s\n",
bd->block, transfer->write_req->bufnum,
dd->phys_dev->capabilities &
RTEMS_BLKDEV_CAP_MULTISECTOR_CONT ? "MULIT" : "SCAT");
if ((dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_MULTISECTOR_CONT) &&
bb7c: e5941018 ldr r1, [r4, #24]
bb80: e5913010 ldr r3, [r1, #16]
}
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
bb84: e2830001 add r0, r3, #1
bb88: e5810010 str r0, [r1, #16]
buf->user = bd;
buf->block = bd->block;
bb8c: e592c01c ldr ip, [r2, #28]
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
bb90: e0810203 add r0, r1, r3, lsl #4
buf->block = bd->block;
bb94: e580c018 str ip, [r0, #24]
buf->length = dd->block_size;
bb98: e595c020 ldr ip, [r5, #32]
bb9c: e580c01c str ip, [r0, #28]
buf->buffer = bd->buffer;
bba0: e592c020 ldr ip, [r2, #32]
bba4: e2833002 add r3, r3, #2
else
{
rtems_blkdev_sg_buffer* buf;
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
bba8: e5802024 str r2, [r0, #36] ; 0x24
buf->block = bd->block;
buf->length = dd->block_size;
buf->buffer = bd->buffer;
last_block = bd->block;
bbac: e592601c ldr r6, [r2, #28]
buf = &transfer->write_req->bufs[transfer->write_req->bufnum];
transfer->write_req->bufnum++;
buf->user = bd;
buf->block = bd->block;
buf->length = dd->block_size;
buf->buffer = bd->buffer;
bbb0: e781c203 str ip, [r1, r3, lsl #4]
last_block = bd->block;
bbb4: e3a02000 mov r2, #0
bbb8: eaffffd1 b bb04 <rtems_bdbuf_swapout_write+0xc8>
if (rtems_chain_is_empty (&transfer->bds) ||
(transfer->write_req->bufnum >= bdbuf_config.max_write_blocks))
write = true;
if (write)
bbbc: e3520000 cmp r2, #0
bbc0: 0affffba beq bab0 <rtems_bdbuf_swapout_write+0x74>
bbc4: eaffffd4 b bb1c <rtems_bdbuf_swapout_write+0xe0> <== NOT EXECUTED
}
rtems_disk_release (dd);
}
}
}
bbc8: e28dd004 add sp, sp, #4 <== NOT EXECUTED
bbcc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* call perform the call.
*/
if (transfer->syncing &&
(dd->phys_dev->capabilities & RTEMS_BLKDEV_CAP_SYNC))
{
/* int result = */ dd->ioctl (dd->phys_dev, RTEMS_BLKDEV_REQ_SYNC, NULL);
bbd0: e3a01002 mov r1, #2 <== NOT EXECUTED
bbd4: e1a0e00f mov lr, pc <== NOT EXECUTED
bbd8: e595f028 ldr pc, [r5, #40] ; 0x28 <== NOT EXECUTED
bbdc: eaffffe2 b bb6c <rtems_bdbuf_swapout_write+0x130> <== NOT EXECUTED
0000b130 <rtems_bdbuf_swapout_writereq_alloc>:
* I am disappointment at finding code like this in RTEMS. The request should
* have been a rtems_chain_control. Simple, fast and less storage as the node
* is already part of the buffer structure.
*/
rtems_blkdev_request* write_req =
malloc (sizeof (rtems_blkdev_request) +
b130: e59f3044 ldr r3, [pc, #68] ; b17c <rtems_bdbuf_swapout_writereq_alloc+0x4c>
b134: e5930004 ldr r0, [r3, #4]
b138: e1a00200 lsl r0, r0, #4
*
* @return rtems_blkdev_request* The write reference memory.
*/
static rtems_blkdev_request*
rtems_bdbuf_swapout_writereq_alloc (void)
{
b13c: e92d4010 push {r4, lr}
* I am disappointment at finding code like this in RTEMS. The request should
* have been a rtems_chain_control. Simple, fast and less storage as the node
* is already part of the buffer structure.
*/
rtems_blkdev_request* write_req =
malloc (sizeof (rtems_blkdev_request) +
b140: e2800018 add r0, r0, #24
b144: ebffe0c6 bl 3464 <malloc>
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
b148: e2504000 subs r4, r0, #0
b14c: 0a000007 beq b170 <rtems_bdbuf_swapout_writereq_alloc+0x40>
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
write_req->req = RTEMS_BLKDEV_REQ_WRITE;
b150: e3a03001 mov r3, #1
b154: e5843000 str r3, [r4]
write_req->req_done = rtems_bdbuf_transfer_done;
b158: e59f3020 ldr r3, [pc, #32] ; b180 <rtems_bdbuf_swapout_writereq_alloc+0x50>
write_req->done_arg = write_req;
b15c: e9840018 stmib r4, {r3, r4}
write_req->io_task = rtems_task_self ();
b160: eb001157 bl f6c4 <rtems_task_self>
b164: e5840014 str r0, [r4, #20]
return write_req;
}
b168: e1a00004 mov r0, r4
b16c: e8bd8010 pop {r4, pc}
rtems_blkdev_request* write_req =
malloc (sizeof (rtems_blkdev_request) +
(bdbuf_config.max_write_blocks * sizeof (rtems_blkdev_sg_buffer)));
if (!write_req)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_NOMEM);
b170: e2800442 add r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
b174: e2800015 add r0, r0, #21 <== NOT EXECUTED
b178: ebffefde bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000bff0 <rtems_bdbuf_sync>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
bff0: e92d4030 push {r4, r5, lr}
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
bff4: e59f5150 ldr r5, [pc, #336] ; c14c <rtems_bdbuf_sync+0x15c>
bff8: e5d53088 ldrb r3, [r5, #136] ; 0x88
bffc: e3530000 cmp r3, #0
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_bdbuf_sync (rtems_bdbuf_buffer *bd)
{
c000: e1a04000 mov r4, r0
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
c004: 03a00016 moveq r0, #22
}
static rtems_status_code
rtems_bdbuf_check_bd_and_lock_cache (rtems_bdbuf_buffer *bd, const char *kind)
{
if (!bdbuf_cache.initialised)
c008: 08bd8030 popeq {r4, r5, pc}
return RTEMS_NOT_CONFIGURED;
if (bd == NULL)
c00c: e3540000 cmp r4, #0
c010: 03a00009 moveq r0, #9
c014: 08bd8030 popeq {r4, r5, pc}
if (rtems_bdbuf_tracer)
{
printf ("bdbuf:%s: %" PRIu32 "\n", kind, bd->block);
rtems_bdbuf_show_users (kind, bd);
}
rtems_bdbuf_lock_cache();
c018: ebfff9ac bl a6d0 <rtems_bdbuf_lock_cache>
sc = rtems_bdbuf_check_bd_and_lock_cache (bd, "sync");
if (sc != RTEMS_SUCCESSFUL)
return sc;
switch (bd->state)
c01c: e5943024 ldr r3, [r4, #36] ; 0x24
c020: e3530003 cmp r3, #3
c024: 3a000003 bcc c038 <rtems_bdbuf_sync+0x48>
c028: e3530005 cmp r3, #5
c02c: 9a00000b bls c060 <rtems_bdbuf_sync+0x70>
c030: e3530006 cmp r3, #6
c034: 0a000004 beq c04c <rtems_bdbuf_sync+0x5c>
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_5);
c038: e5940024 ldr r0, [r4, #36] ; 0x24 <== NOT EXECUTED
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
c03c: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
c040: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
c044: e3800003 orr r0, r0, #3 <== NOT EXECUTED
c048: ebffec2a bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
case RTEMS_BDBUF_STATE_ACCESS_EMPTY:
case RTEMS_BDBUF_STATE_ACCESS_MODIFIED:
rtems_bdbuf_sync_after_access (bd);
break;
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
rtems_bdbuf_discard_buffer_after_access (bd);
c04c: e1a00004 mov r0, r4
c050: ebfffd3c bl b548 <rtems_bdbuf_discard_buffer_after_access>
}
if (rtems_bdbuf_tracer)
rtems_bdbuf_show_usage ();
rtems_bdbuf_unlock_cache ();
c054: ebfffa18 bl a8bc <rtems_bdbuf_unlock_cache>
c058: e3a00000 mov r0, #0
return RTEMS_SUCCESSFUL;
}
c05c: e8bd8030 pop {r4, r5, pc}
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c060: e3a03008 mov r3, #8
c064: e5843024 str r3, [r4, #36] ; 0x24
c068: e285005c add r0, r5, #92 ; 0x5c
c06c: e1a01004 mov r1, r4
c070: ebffed4c bl 75a8 <_Chain_Append>
{
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
c074: e5943028 ldr r3, [r4, #40] ; 0x28
c078: e3530000 cmp r3, #0
c07c: 1a000027 bne c120 <rtems_bdbuf_sync+0x130>
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
rtems_bdbuf_wake_swapper ();
c080: ebfffa66 bl aa20 <rtems_bdbuf_wake_swapper>
static void
rtems_bdbuf_wait_for_sync_done (rtems_bdbuf_buffer *bd)
{
while (true)
{
switch (bd->state)
c084: e5943024 ldr r3, [r4, #36] ; 0x24
c088: e2433001 sub r3, r3, #1
c08c: e3530009 cmp r3, #9
c090: 979ff103 ldrls pc, [pc, r3, lsl #2]
c094: ea00001c b c10c <rtems_bdbuf_sync+0x11c> <== NOT EXECUTED
c098: 0000c0d0 .word 0x0000c0d0 <== NOT EXECUTED
c09c: 0000c0d0 .word 0x0000c0d0 <== NOT EXECUTED
c0a0: 0000c0d0 .word 0x0000c0d0 <== NOT EXECUTED
c0a4: 0000c0d0 .word 0x0000c0d0 <== NOT EXECUTED
c0a8: 0000c0d0 .word 0x0000c0d0 <== NOT EXECUTED
c0ac: 0000c0d0 .word 0x0000c0d0 <== NOT EXECUTED
c0b0: 0000c0d0 .word 0x0000c0d0 <== NOT EXECUTED
c0b4: 0000c0c0 .word 0x0000c0c0 <== NOT EXECUTED
c0b8: 0000c0c0 .word 0x0000c0c0 <== NOT EXECUTED
c0bc: 0000c0c0 .word 0x0000c0c0 <== NOT EXECUTED
case RTEMS_BDBUF_STATE_ACCESS_PURGED:
return;
case RTEMS_BDBUF_STATE_SYNC:
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
c0c0: e1a00004 mov r0, r4
c0c4: e59f1084 ldr r1, [pc, #132] ; c150 <rtems_bdbuf_sync+0x160>
c0c8: ebfffb0a bl acf8 <rtems_bdbuf_wait>
c0cc: eaffffec b c084 <rtems_bdbuf_sync+0x94>
/*
* We may have created a cached or empty buffer which may be recycled.
*/
if (bd->waiters == 0
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
c0d0: e5943028 ldr r3, [r4, #40] ; 0x28
rtems_bdbuf_wait_for_sync_done (bd);
/*
* We may have created a cached or empty buffer which may be recycled.
*/
if (bd->waiters == 0
c0d4: e3530000 cmp r3, #0
c0d8: 1affffdd bne c054 <rtems_bdbuf_sync+0x64>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
c0dc: e5943024 ldr r3, [r4, #36] ; 0x24
rtems_bdbuf_wait_for_sync_done (bd);
/*
* We may have created a cached or empty buffer which may be recycled.
*/
if (bd->waiters == 0
c0e0: e3530002 cmp r3, #2
c0e4: 0a000002 beq c0f4 <rtems_bdbuf_sync+0x104>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
c0e8: e5943024 ldr r3, [r4, #36] ; 0x24
rtems_bdbuf_wait_for_sync_done (bd);
/*
* We may have created a cached or empty buffer which may be recycled.
*/
if (bd->waiters == 0
c0ec: e3530001 cmp r3, #1
c0f0: 1affffd7 bne c054 <rtems_bdbuf_sync+0x64>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
c0f4: e5943024 ldr r3, [r4, #36] ; 0x24
c0f8: e3530001 cmp r3, #1
c0fc: 0a00000a beq c12c <rtems_bdbuf_sync+0x13c>
{
rtems_bdbuf_remove_from_tree (bd);
rtems_bdbuf_make_free_and_add_to_lru_list (bd);
}
rtems_bdbuf_wake (&bdbuf_cache.buffer_waiters);
c100: e59f004c ldr r0, [pc, #76] ; c154 <rtems_bdbuf_sync+0x164>
c104: ebfff977 bl a6e8 <rtems_bdbuf_wake>
c108: eaffffd1 b c054 <rtems_bdbuf_sync+0x64>
case RTEMS_BDBUF_STATE_TRANSFER:
case RTEMS_BDBUF_STATE_TRANSFER_PURGED:
rtems_bdbuf_wait (bd, &bdbuf_cache.transfer_waiters);
break;
default:
rtems_bdbuf_fatal (bd->state, RTEMS_BLKDEV_FATAL_BDBUF_STATE_9);
c10c: e5940024 ldr r0, [r4, #36] ; 0x24 <== NOT EXECUTED
#endif
static void
rtems_bdbuf_fatal (rtems_bdbuf_buf_state state, uint32_t error)
{
rtems_fatal_error_occurred ((((uint32_t) state) << 16) | error);
c110: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
c114: e3800442 orr r0, r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
c118: e3800007 orr r0, r0, #7 <== NOT EXECUTED
c11c: ebffebf5 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
rtems_bdbuf_set_state (bd, RTEMS_BDBUF_STATE_SYNC);
rtems_chain_append (&bdbuf_cache.sync, &bd->link);
if (bd->waiters)
rtems_bdbuf_wake (&bdbuf_cache.access_waiters);
c120: e2850068 add r0, r5, #104 ; 0x68
c124: ebfff96f bl a6e8 <rtems_bdbuf_wake>
c128: eaffffd4 b c080 <rtems_bdbuf_sync+0x90>
&& (bd->state == RTEMS_BDBUF_STATE_CACHED
|| bd->state == RTEMS_BDBUF_STATE_EMPTY))
{
if (bd->state == RTEMS_BDBUF_STATE_EMPTY)
{
rtems_bdbuf_remove_from_tree (bd);
c12c: e1a00004 mov r0, r4
c130: ebfffc13 bl b184 <rtems_bdbuf_remove_from_tree>
}
static void
rtems_bdbuf_set_state (rtems_bdbuf_buffer *bd, rtems_bdbuf_buf_state state)
{
bd->state = state;
c134: e3a03000 mov r3, #0
c138: e5843024 str r3, [r4, #36] ; 0x24
RTEMS_INLINE_ROUTINE void _Chain_Prepend(
Chain_Control *the_chain,
Chain_Node *the_node
)
{
_Chain_Insert(_Chain_Head(the_chain), the_node);
c13c: e1a01004 mov r1, r4
c140: e59f0010 ldr r0, [pc, #16] ; c158 <rtems_bdbuf_sync+0x168>
c144: eb000e33 bl fa18 <_Chain_Insert>
c148: eaffffec b c100 <rtems_bdbuf_sync+0x110>
0000a8bc <rtems_bdbuf_unlock_cache>:
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
a8bc: e59f301c ldr r3, [pc, #28] ; a8e0 <rtems_bdbuf_unlock_cache+0x24>
/**
* Unlock the cache.
*/
static void
rtems_bdbuf_unlock_cache (void)
{
a8c0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
a8c4: e5930028 ldr r0, [r3, #40] ; 0x28
a8c8: ebfff0da bl 6c38 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
a8cc: e3500000 cmp r0, #0
a8d0: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred (fatal_error_code);
a8d4: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
a8d8: e280000e add r0, r0, #14 <== NOT EXECUTED
a8dc: ebfff205 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000a8e4 <rtems_bdbuf_unlock_sync>:
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
a8e4: e59f301c ldr r3, [pc, #28] ; a908 <rtems_bdbuf_unlock_sync+0x24>
/**
* Unlock the cache's sync lock. Any blocked writers are woken.
*/
static void
rtems_bdbuf_unlock_sync (void)
{
a8e8: e52de004 push {lr} ; (str lr, [sp, #-4]!)
* @param fatal_error_code The error code if the call fails.
*/
static void
rtems_bdbuf_unlock (rtems_id lock, uint32_t fatal_error_code)
{
rtems_status_code sc = rtems_semaphore_release (lock);
a8ec: e593002c ldr r0, [r3, #44] ; 0x2c
a8f0: ebfff0d0 bl 6c38 <rtems_semaphore_release>
if (sc != RTEMS_SUCCESSFUL)
a8f4: e3500000 cmp r0, #0
a8f8: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred (fatal_error_code);
a8fc: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
a900: e280000c add r0, r0, #12 <== NOT EXECUTED
a904: ebfff1fb bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000ab28 <rtems_bdbuf_wait_for_event>:
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
ab28: e92d4010 push {r4, lr}
ab2c: e24dd004 sub sp, sp, #4
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_event_set out = 0;
ab30: e3a01000 mov r1, #0
ab34: e28d3004 add r3, sp, #4
ab38: e5231004 str r1, [r3, #-4]!
sc = rtems_event_receive (event,
ab3c: e1a02001 mov r2, r1
ab40: e1a0300d mov r3, sp
return RTEMS_UNSATISFIED;
}
static void
rtems_bdbuf_wait_for_event (rtems_event_set event)
{
ab44: e1a04000 mov r4, r0
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_event_set out = 0;
sc = rtems_event_receive (event,
ab48: ebffee6e bl 6508 <rtems_event_receive>
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
ab4c: e3500000 cmp r0, #0
ab50: 1a000004 bne ab68 <rtems_bdbuf_wait_for_event+0x40>
ab54: e59d3000 ldr r3, [sp]
ab58: e1530004 cmp r3, r4
ab5c: 1a000001 bne ab68 <rtems_bdbuf_wait_for_event+0x40>
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_WAIT_EVNT);
}
ab60: e28dd004 add sp, sp, #4
ab64: e8bd8010 pop {r4, pc}
RTEMS_EVENT_ALL | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&out);
if (sc != RTEMS_SUCCESSFUL || out != event)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_WAIT_EVNT);
ab68: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
ab6c: e280001a add r0, r0, #26 <== NOT EXECUTED
ab70: ebfff160 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000a6e8 <rtems_bdbuf_wake>:
static void
rtems_bdbuf_wake (const rtems_bdbuf_waiters *waiters)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
a6e8: e5903000 ldr r3, [r0]
a6ec: e3530000 cmp r3, #0
* Wake a blocked resource. The resource has a counter that lets us know if
* there are any waiters.
*/
static void
rtems_bdbuf_wake (const rtems_bdbuf_waiters *waiters)
{
a6f0: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc = RTEMS_SUCCESSFUL;
if (waiters->count > 0)
a6f4: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
{
sc = rtems_semaphore_flush (waiters->sema);
a6f8: e5900004 ldr r0, [r0, #4]
a6fc: eb00136b bl f4b0 <rtems_semaphore_flush>
if (sc != RTEMS_SUCCESSFUL)
a700: e3500000 cmp r0, #0
a704: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_CACHE_WAKE);
a708: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
a70c: e2800013 add r0, r0, #19 <== NOT EXECUTED
a710: ebfff278 bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000aa20 <rtems_bdbuf_wake_swapper>:
}
static void
rtems_bdbuf_wake_swapper (void)
{
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
aa20: e59f3020 ldr r3, [pc, #32] ; aa48 <rtems_bdbuf_wake_swapper+0x28>
}
}
static void
rtems_bdbuf_wake_swapper (void)
{
aa24: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc = rtems_event_send (bdbuf_cache.swapout,
aa28: e5930000 ldr r0, [r3]
aa2c: e3a01004 mov r1, #4
aa30: ebffef12 bl 6680 <rtems_event_send>
RTEMS_BDBUF_SWAPOUT_SYNC);
if (sc != RTEMS_SUCCESSFUL)
aa34: e3500000 cmp r0, #0
aa38: 049df004 popeq {pc} ; (ldreq pc, [sp], #4)
rtems_fatal_error_occurred (RTEMS_BLKDEV_FATAL_BDBUF_SO_WAKE);
aa3c: e3a00442 mov r0, #1107296256 ; 0x42000000 <== NOT EXECUTED
aa40: e2800014 add r0, r0, #20 <== NOT EXECUTED
aa44: ebfff1ab bl 70f8 <rtems_fatal_error_occurred> <== NOT EXECUTED
00023cf0 <rtems_bdpart_create>:
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
23cf0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL; bool dos_compatibility = format != NULL
23cf4: e2514000 subs r4, r1, #0 <== NOT EXECUTED
const rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
const unsigned *dist,
size_t count
)
{
23cf8: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 23cfc: e1a05002 mov r5, r2 <== NOT EXECUTED 23d00: e1a07003 mov r7, r3 <== NOT EXECUTED 23d04: e59d604c ldr r6, [sp, #76] ; 0x4c <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL; bool dos_compatibility = format != NULL
23d08: 0a000002 beq 23d18 <rtems_bdpart_create+0x28> <== NOT EXECUTED
&& format->type == RTEMS_BDPART_FORMAT_MBR
23d0c: e5943000 ldr r3, [r4] <== NOT EXECUTED 23d10: e3530000 cmp r3, #0 <== NOT EXECUTED 23d14: 0a000073 beq 23ee8 <rtems_bdpart_create+0x1f8> <== NOT EXECUTED
&& format->mbr.dos_compatibility;
rtems_blkdev_bnum disk_end = 0;
23d18: e3a0b000 mov fp, #0 <== NOT EXECUTED 23d1c: e58db024 str fp, [sp, #36] ; 0x24 <== NOT EXECUTED 23d20: e3a08001 mov r8, #1 <== NOT EXECUTED
rtems_blkdev_bnum free_space = 0;
dev_t disk = 0;
size_t i = 0;
/* Check if we have something to do */
if (count == 0) {
23d24: e3560000 cmp r6, #0 <== NOT EXECUTED 23d28: 01a09006 moveq r9, r6 <== NOT EXECUTED 23d2c: 0a00006a beq 23edc <rtems_bdpart_create+0x1ec> <== NOT EXECUTED
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL || dist == NULL) {
23d30: e3540000 cmp r4, #0 <== NOT EXECUTED 23d34: 13550000 cmpne r5, #0 <== NOT EXECUTED 23d38: 0a000071 beq 23f04 <rtems_bdpart_create+0x214> <== NOT EXECUTED 23d3c: e3570000 cmp r7, #0 <== NOT EXECUTED 23d40: 0a00006f beq 23f04 <rtems_bdpart_create+0x214> <== NOT EXECUTED
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
rtems_blkdev_bnum overhead = 0;
rtems_blkdev_bnum free_space = 0;
dev_t disk = 0;
23d44: e3a09000 mov r9, #0 <== NOT EXECUTED
if (format == NULL || pt == NULL || dist == NULL) {
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
23d48: e28d101c add r1, sp, #28 <== NOT EXECUTED 23d4c: e28d2024 add r2, sp, #36 ; 0x24 <== NOT EXECUTED
rtems_blkdev_bnum dist_sum = 0;
rtems_blkdev_bnum record_space =
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
rtems_blkdev_bnum overhead = 0;
rtems_blkdev_bnum free_space = 0;
dev_t disk = 0;
23d50: e3a0a000 mov sl, #0 <== NOT EXECUTED 23d54: e58d901c str r9, [sp, #28] <== NOT EXECUTED 23d58: e58da020 str sl, [sp, #32] <== NOT EXECUTED
if (format == NULL || pt == NULL || dist == NULL) {
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
23d5c: eb00019c bl 243d4 <rtems_bdpart_get_disk_data> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
23d60: e2509000 subs r9, r0, #0 <== NOT EXECUTED 23d64: 1a00005c bne 23edc <rtems_bdpart_create+0x1ec> <== NOT EXECUTED
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
23d68: e5973000 ldr r3, [r7] <== NOT EXECUTED
if (dist_sum < prev_sum) {
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
23d6c: e3530000 cmp r3, #0 <== NOT EXECUTED 23d70: 11a0a003 movne sl, r3 <== NOT EXECUTED 23d74: 11a02009 movne r2, r9 <== NOT EXECUTED 23d78: 1a000005 bne 23d94 <rtems_bdpart_create+0xa4> <== NOT EXECUTED 23d7c: ea000062 b 23f0c <rtems_bdpart_create+0x21c> <== NOT EXECUTED
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
unsigned prev_sum = dist_sum;
dist_sum += dist [i];
23d80: e7971102 ldr r1, [r7, r2, lsl #2] <== NOT EXECUTED
if (dist_sum < prev_sum) {
23d84: e09aa001 adds sl, sl, r1 <== NOT EXECUTED 23d88: 2a00005f bcs 23f0c <rtems_bdpart_create+0x21c> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
}
if (dist [i] == 0) {
23d8c: e3510000 cmp r1, #0 <== NOT EXECUTED 23d90: 0a00005d beq 23f0c <rtems_bdpart_create+0x21c> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Get distribution sum and check for overflow */
for (i = 0; i < count; ++i) {
23d94: e2822001 add r2, r2, #1 <== NOT EXECUTED 23d98: e1560002 cmp r6, r2 <== NOT EXECUTED 23d9c: 8afffff7 bhi 23d80 <rtems_bdpart_create+0x90> <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
23da0: e5942000 ldr r2, [r4] <== NOT EXECUTED 23da4: e3520000 cmp r2, #0 <== NOT EXECUTED 23da8: 13a09018 movne r9, #24 <== NOT EXECUTED 23dac: 1a00004a bne 23edc <rtems_bdpart_create+0x1ec> <== NOT EXECUTED
return RTEMS_NOT_IMPLEMENTED;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
23db0: e35b0000 cmp fp, #0 <== NOT EXECUTED 23db4: 1a000056 bne 23f14 <rtems_bdpart_create+0x224> <== NOT EXECUTED 23db8: e59d0024 ldr r0, [sp, #36] ; 0x24 <== NOT EXECUTED 23dbc: e58d0010 str r0, [sp, #16] <== NOT EXECUTED
/*
* In case we need an extended partition and logical partitions we have to
* account for the space of each EBR.
*/
if (count > 4) {
23dc0: e3560004 cmp r6, #4 <== NOT EXECUTED
overhead += (count - 3) * record_space;
23dc4: 82461003 subhi r1, r6, #3 <== NOT EXECUTED 23dc8: 80228891 mlahi r2, r1, r8, r8 <== NOT EXECUTED
/*
* In case we need an extended partition and logical partitions we have to
* account for the space of each EBR.
*/
if (count > 4) {
23dcc: 91a02008 movls r2, r8 <== NOT EXECUTED
/*
* Account space to align every partition on cylinder boundaries if
* necessary.
*/
if (dos_compatibility) {
23dd0: e35b0000 cmp fp, #0 <== NOT EXECUTED
overhead += (count - 1) * record_space;
23dd4: 12461001 subne r1, r6, #1 <== NOT EXECUTED 23dd8: 10222891 mlane r2, r1, r8, r2 <== NOT EXECUTED
}
/* Check disk space */
if ((overhead + count) > disk_end) {
23ddc: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED 23de0: e0821006 add r1, r2, r6 <== NOT EXECUTED 23de4: e1510000 cmp r1, r0 <== NOT EXECUTED 23de8: 83a0901b movhi r9, #27 <== NOT EXECUTED 23dec: 8a00003a bhi 23edc <rtems_bdpart_create+0x1ec> <== NOT EXECUTED
/* Begin of first primary partition */
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
23df0: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED 23df4: e0621000 rsb r1, r2, r0 <== NOT EXECUTED
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
23df8: e0000193 mul r0, r3, r1 <== NOT EXECUTED
if (s < free_space || s < dist [i]) {
23dfc: e1510000 cmp r1, r0 <== NOT EXECUTED 23e00: 8a000041 bhi 23f0c <rtems_bdpart_create+0x21c> <== NOT EXECUTED 23e04: e1500003 cmp r0, r3 <== NOT EXECUTED 23e08: 3a00003f bcc 23f0c <rtems_bdpart_create+0x21c> <== NOT EXECUTED 23e0c: e3560004 cmp r6, #4 <== NOT EXECUTED 23e10: 93a02000 movls r2, #0 <== NOT EXECUTED 23e14: 83a02001 movhi r2, #1 <== NOT EXECUTED 23e18: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 23e1c: e1a02005 mov r2, r5 <== NOT EXECUTED 23e20: e58d9014 str r9, [sp, #20] <== NOT EXECUTED 23e24: e58d700c str r7, [sp, #12] <== NOT EXECUTED 23e28: e1a0b008 mov fp, r8 <== NOT EXECUTED 23e2c: e3a04000 mov r4, #0 <== NOT EXECUTED 23e30: e58da008 str sl, [sp, #8] <== NOT EXECUTED 23e34: e1a09001 mov r9, r1 <== NOT EXECUTED 23e38: e58d5018 str r5, [sp, #24] <== NOT EXECUTED 23e3c: e1a07002 mov r7, r2 <== NOT EXECUTED 23e40: ea000008 b 23e68 <rtems_bdpart_create+0x178> <== NOT EXECUTED
for (i = 0; i < count; ++i) {
rtems_bdpart_partition *p = pt + i;
/* Partition size */
rtems_blkdev_bnum s = free_space * dist [i];
23e44: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED 23e48: e7903104 ldr r3, [r0, r4, lsl #2] <== NOT EXECUTED 23e4c: e0000993 mul r0, r3, r9 <== NOT EXECUTED
if (s < free_space || s < dist [i]) {
23e50: e1590000 cmp r9, r0 <== NOT EXECUTED 23e54: 8a00002c bhi 23f0c <rtems_bdpart_create+0x21c> <== NOT EXECUTED 23e58: e1530000 cmp r3, r0 <== NOT EXECUTED 23e5c: e2877030 add r7, r7, #48 ; 0x30 <== NOT EXECUTED 23e60: 8a000029 bhi 23f0c <rtems_bdpart_create+0x21c> <== NOT EXECUTED 23e64: e1a05007 mov r5, r7 <== NOT EXECUTED
/* TODO: Calculate without overflow */
return RTEMS_INVALID_NUMBER;
}
s /= dist_sum;
23e68: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 23e6c: eb00dc1d bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
/* Ensure that the partition is not empty */
if (s == 0) {
23e70: e3500000 cmp r0, #0 <== NOT EXECUTED 23e74: 11a03000 movne r3, r0 <== NOT EXECUTED 23e78: 03a03001 moveq r3, #1 <== NOT EXECUTED
/* Align partition upwards */
s += record_space - (s % record_space);
/* Partition begin and end */
p->begin = pos;
23e7c: e585b000 str fp, [r5] <== NOT EXECUTED
if (s == 0) {
s = 1;
}
/* Align partition upwards */
s += record_space - (s % record_space);
23e80: e08ba008 add sl, fp, r8 <== NOT EXECUTED
/* Partition begin and end */
p->begin = pos;
pos += s;
23e84: e1a00003 mov r0, r3 <== NOT EXECUTED 23e88: e1a01008 mov r1, r8 <== NOT EXECUTED 23e8c: e083b00a add fp, r3, sl <== NOT EXECUTED 23e90: eb00dca8 bl 5b138 <__umodsi3> <== NOT EXECUTED
p->end = pos;
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
23e94: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 23e98: e3540002 cmp r4, #2 <== NOT EXECUTED 23e9c: 93a03000 movls r3, #0 <== NOT EXECUTED 23ea0: 82033001 andhi r3, r3, #1 <== NOT EXECUTED 23ea4: e3530000 cmp r3, #0 <== NOT EXECUTED
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
23ea8: e2844001 add r4, r4, #1 <== NOT EXECUTED
/* Align partition upwards */
s += record_space - (s % record_space);
/* Partition begin and end */
p->begin = pos;
pos += s;
23eac: e060b00b rsb fp, r0, fp <== NOT EXECUTED
p->end = pos;
/* Reserve space for the EBR if necessary */
if (count > 4 && i > 2) {
p->begin += record_space;
23eb0: 1585a000 strne sl, [r5] <== NOT EXECUTED
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
23eb4: e1560004 cmp r6, r4 <== NOT EXECUTED
s += record_space - (s % record_space);
/* Partition begin and end */
p->begin = pos;
pos += s;
p->end = pos;
23eb8: e585b004 str fp, [r5, #4] <== NOT EXECUTED
pos = record_space;
/* Space for partitions */
free_space = disk_end - overhead;
for (i = 0; i < count; ++i) {
23ebc: 8affffe0 bhi 23e44 <rtems_bdpart_create+0x154> <== NOT EXECUTED 23ec0: e59d5018 ldr r5, [sp, #24] <== NOT EXECUTED
p->begin += record_space;
}
}
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
23ec4: e2466001 sub r6, r6, #1 <== NOT EXECUTED 23ec8: e0866086 add r6, r6, r6, lsl #1 <== NOT EXECUTED 23ecc: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 23ed0: e0855206 add r5, r5, r6, lsl #4 <== NOT EXECUTED 23ed4: e59d9014 ldr r9, [sp, #20] <== NOT EXECUTED 23ed8: e5852004 str r2, [r5, #4] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
23edc: e1a00009 mov r0, r9 <== NOT EXECUTED
23ee0: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
23ee4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
23ee8: e5d42008 ldrb r2, [r4, #8] <== NOT EXECUTED 23eec: e3520000 cmp r2, #0 <== NOT EXECUTED 23ef0: 0affff88 beq 23d18 <rtems_bdpart_create+0x28> <== NOT EXECUTED
rtems_blkdev_bnum disk_end = 0;
23ef4: e58d3024 str r3, [sp, #36] ; 0x24 <== NOT EXECUTED 23ef8: e3a0b001 mov fp, #1 <== NOT EXECUTED 23efc: e3a0803f mov r8, #63 ; 0x3f <== NOT EXECUTED 23f00: eaffff87 b 23d24 <rtems_bdpart_create+0x34> <== NOT EXECUTED
}
/* Expand the last partition to the disk end */
pt [count - 1].end = disk_end;
return RTEMS_SUCCESSFUL;
23f04: e3a09009 mov r9, #9 <== NOT EXECUTED 23f08: eafffff3 b 23edc <rtems_bdpart_create+0x1ec> <== NOT EXECUTED 23f0c: e3a0900a mov r9, #10 <== NOT EXECUTED 23f10: eafffff1 b 23edc <rtems_bdpart_create+0x1ec> <== NOT EXECUTED
return RTEMS_NOT_IMPLEMENTED;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
23f14: e59d4024 ldr r4, [sp, #36] ; 0x24 <== NOT EXECUTED 23f18: e1a01008 mov r1, r8 <== NOT EXECUTED 23f1c: e1a00004 mov r0, r4 <== NOT EXECUTED 23f20: e58d3000 str r3, [sp] <== NOT EXECUTED 23f24: eb00dc83 bl 5b138 <__umodsi3> <== NOT EXECUTED 23f28: e0604004 rsb r4, r0, r4 <== NOT EXECUTED 23f2c: e58d4010 str r4, [sp, #16] <== NOT EXECUTED 23f30: e59d3000 ldr r3, [sp] <== NOT EXECUTED 23f34: eaffffa1 b 23dc0 <rtems_bdpart_create+0xd0> <== NOT EXECUTED
00023f38 <rtems_bdpart_dump>:
{
uuid_unparse_lower( type, str);
}
void rtems_bdpart_dump( const rtems_bdpart_partition *pt, size_t count)
{
23f38: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
23f3c: e1a06001 mov r6, r1 <== NOT EXECUTED
23f40: e24dd038 sub sp, sp, #56 ; 0x38 <== NOT EXECUTED
23f44: e1a04000 mov r4, r0 <== NOT EXECUTED
size_t i = 0;
printf(
23f48: e59f00fc ldr r0, [pc, #252] ; 2404c <rtems_bdpart_dump+0x114><== NOT EXECUTED 23f4c: eb008e2a bl 477fc <puts> <== NOT EXECUTED
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
23f50: e3560000 cmp r6, #0 <== NOT EXECUTED 23f54: 0a00002c beq 2400c <rtems_bdpart_dump+0xd4> <== NOT EXECUTED 23f58: e3a05000 mov r5, #0 <== NOT EXECUTED 23f5c: e28d7037 add r7, sp, #55 ; 0x37 <== NOT EXECUTED
const rtems_bdpart_partition *p = pt + i;
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
23f60: e1a08005 mov r8, r5 <== NOT EXECUTED
static void rtems_bdpart_type_to_string(
const uuid_t type,
char str [37]
)
{
uuid_unparse_lower( type, str);
23f64: e1a0a00d mov sl, sp <== NOT EXECUTED 23f68: ea000015 b 23fc4 <rtems_bdpart_dump+0x8c> <== NOT EXECUTED
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
switch (type_mbr) {
23f6c: e5dd3037 ldrb r3, [sp, #55] ; 0x37 <== NOT EXECUTED 23f70: e353000b cmp r3, #11 <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_16:
type = "FAT 16";
break;
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
break;
23f74: 059f30d4 ldreq r3, [pc, #212] ; 24050 <rtems_bdpart_dump+0x118><== NOT EXECUTED
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
switch (type_mbr) {
23f78: 0a00000a beq 23fa8 <rtems_bdpart_dump+0x70> <== NOT EXECUTED 23f7c: 8a000026 bhi 2401c <rtems_bdpart_dump+0xe4> <== NOT EXECUTED 23f80: e3530001 cmp r3, #1 <== NOT EXECUTED 23f84: 059f30c8 ldreq r3, [pc, #200] ; 24054 <rtems_bdpart_dump+0x11c><== NOT EXECUTED 23f88: 0a000006 beq 23fa8 <rtems_bdpart_dump+0x70> <== NOT EXECUTED 23f8c: e3530004 cmp r3, #4 <== NOT EXECUTED 23f90: 0a00002b beq 24044 <rtems_bdpart_dump+0x10c> <== NOT EXECUTED
break;
case RTEMS_BDPART_MBR_DATA:
type = "DATA";
break;
default:
snprintf( type_buffer, sizeof( type_buffer), "0x%02" PRIx8, type_mbr);
23f94: e1a0000d mov r0, sp <== NOT EXECUTED 23f98: e3a01034 mov r1, #52 ; 0x34 <== NOT EXECUTED 23f9c: e59f20b4 ldr r2, [pc, #180] ; 24058 <rtems_bdpart_dump+0x120><== NOT EXECUTED 23fa0: eb0092fd bl 48b9c <snprintf> <== NOT EXECUTED 23fa4: e1a0300d mov r3, sp <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
23fa8: e8940006 ldm r4, {r1, r2} <== NOT EXECUTED
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
23fac: e2855001 add r5, r5, #1 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
23fb0: e59f00a4 ldr r0, [pc, #164] ; 2405c <rtems_bdpart_dump+0x124><== NOT EXECUTED 23fb4: eb008d6b bl 47568 <printf> <== NOT EXECUTED
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
23fb8: e1560005 cmp r6, r5 <== NOT EXECUTED 23fbc: e2844030 add r4, r4, #48 ; 0x30 <== NOT EXECUTED 23fc0: 9a000011 bls 2400c <rtems_bdpart_dump+0xd4> <== NOT EXECUTED
const rtems_bdpart_partition *p = pt + i;
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
23fc4: e2849008 add r9, r4, #8 <== NOT EXECUTED 23fc8: e1a00009 mov r0, r9 <== NOT EXECUTED 23fcc: e1a01007 mov r1, r7 <== NOT EXECUTED
for (i = 0; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
23fd0: e5cd8037 strb r8, [sp, #55] ; 0x37 <== NOT EXECUTED
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
23fd4: eb00011c bl 2444c <rtems_bdpart_to_mbr_partition_type> <== NOT EXECUTED 23fd8: e3500000 cmp r0, #0 <== NOT EXECUTED 23fdc: 1affffe2 bne 23f6c <rtems_bdpart_dump+0x34> <== NOT EXECUTED
static void rtems_bdpart_type_to_string(
const uuid_t type,
char str [37]
)
{
uuid_unparse_lower( type, str);
23fe0: e1a00009 mov r0, r9 <== NOT EXECUTED 23fe4: e1a0100d mov r1, sp <== NOT EXECUTED 23fe8: eb006a7c bl 3e9e0 <uuid_unparse_lower> <== NOT EXECUTED
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
23fec: e2855001 add r5, r5, #1 <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
23ff0: e8940006 ldm r4, {r1, r2} <== NOT EXECUTED
static void rtems_bdpart_type_to_string(
const uuid_t type,
char str [37]
)
{
uuid_unparse_lower( type, str);
23ff4: e1a0300d mov r3, sp <== NOT EXECUTED
} else {
rtems_bdpart_type_to_string( p->type, type_buffer);
type = type_buffer;
}
printf(
23ff8: e59f005c ldr r0, [pc, #92] ; 2405c <rtems_bdpart_dump+0x124><== NOT EXECUTED 23ffc: eb008d59 bl 47568 <printf> <== NOT EXECUTED
"------------+------------+-----------------------------------------------------\n"
" BEGIN | END | TYPE\n"
"------------+------------+-----------------------------------------------------\n"
);
for (i = 0; i < count; ++i) {
24000: e1560005 cmp r6, r5 <== NOT EXECUTED 24004: e2844030 add r4, r4, #48 ; 0x30 <== NOT EXECUTED 24008: 8affffed bhi 23fc4 <rtems_bdpart_dump+0x8c> <== NOT EXECUTED
p->end,
type
);
}
puts( "------------+------------+-----------------------------------------------------");
2400c: e59f004c ldr r0, [pc, #76] ; 24060 <rtems_bdpart_dump+0x128><== NOT EXECUTED 24010: eb008df9 bl 477fc <puts> <== NOT EXECUTED
}
24014: e28dd038 add sp, sp, #56 ; 0x38 <== NOT EXECUTED
24018: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
switch (type_mbr) {
2401c: e353000e cmp r3, #14 <== NOT EXECUTED 24020: 059f303c ldreq r3, [pc, #60] ; 24064 <rtems_bdpart_dump+0x12c><== NOT EXECUTED 24024: 0affffdf beq 23fa8 <rtems_bdpart_dump+0x70> <== NOT EXECUTED 24028: e35300da cmp r3, #218 ; 0xda <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
2402c: 059f3034 ldreq r3, [pc, #52] ; 24068 <rtems_bdpart_dump+0x130><== NOT EXECUTED
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
switch (type_mbr) {
24030: 0affffdc beq 23fa8 <rtems_bdpart_dump+0x70> <== NOT EXECUTED 24034: e353000c cmp r3, #12 <== NOT EXECUTED 24038: 1affffd5 bne 23f94 <rtems_bdpart_dump+0x5c> <== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_16_LBA:
type = "FAT 16 LBA";
break;
case RTEMS_BDPART_MBR_FAT_32:
type = "FAT 32";
break;
2403c: e59f3028 ldr r3, [pc, #40] ; 2406c <rtems_bdpart_dump+0x134><== NOT EXECUTED
case RTEMS_BDPART_MBR_FAT_32_LBA:
type = "FAT 32 LBA";
break;
24040: eaffffd8 b 23fa8 <rtems_bdpart_dump+0x70> <== NOT EXECUTED
const char *type = NULL;
char type_buffer [52];
uint8_t type_mbr = 0;
if (rtems_bdpart_to_mbr_partition_type( p->type, &type_mbr)) {
switch (type_mbr) {
24044: e59f3024 ldr r3, [pc, #36] ; 24070 <rtems_bdpart_dump+0x138><== NOT EXECUTED 24048: eaffffd6 b 23fa8 <rtems_bdpart_dump+0x70> <== NOT EXECUTED
000243d4 <rtems_bdpart_get_disk_data>:
rtems_status_code rtems_bdpart_get_disk_data(
const char *disk_name,
dev_t *disk,
rtems_blkdev_bnum *disk_end
)
{
243d4: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
243d8: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED
243dc: e1a04001 mov r4, r1 <== NOT EXECUTED
rtems_blkdev_bnum block_size = 0;
rtems_disk_device *dd = NULL;
struct stat st;
/* Get disk handle */
rv = stat( disk_name, &st);
243e0: e1a0100d mov r1, sp <== NOT EXECUTED
rtems_status_code rtems_bdpart_get_disk_data(
const char *disk_name,
dev_t *disk,
rtems_blkdev_bnum *disk_end
)
{
243e4: e1a05002 mov r5, r2 <== NOT EXECUTED
rtems_blkdev_bnum block_size = 0;
rtems_disk_device *dd = NULL;
struct stat st;
/* Get disk handle */
rv = stat( disk_name, &st);
243e8: ebff9492 bl 9638 <stat> <== NOT EXECUTED
if (rv != 0) {
243ec: e3500000 cmp r0, #0 <== NOT EXECUTED 243f0: 0a000002 beq 24400 <rtems_bdpart_get_disk_data+0x2c> <== NOT EXECUTED
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
return RTEMS_IO_ERROR;
}
/* Check that we have do not have a logical disk */
if (disk_begin != 0) {
243f4: e3a00003 mov r0, #3 <== NOT EXECUTED
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
243f8: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
243fc: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
/* Get disk handle */
rv = stat( disk_name, &st);
if (rv != 0) {
return RTEMS_INVALID_NAME;
}
*disk = st.st_rdev;
24400: e28d1018 add r1, sp, #24 <== NOT EXECUTED
24404: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
24408: e8840003 stm r4, {r0, r1} <== NOT EXECUTED
/* Get disk begin, end and block size */
dd = rtems_disk_obtain( *disk);
2440c: ebff88f2 bl 67dc <rtems_disk_obtain> <== NOT EXECUTED
if (dd == NULL) {
24410: e2503000 subs r3, r0, #0 <== NOT EXECUTED 24414: 0afffff6 beq 243f4 <rtems_bdpart_get_disk_data+0x20> <== NOT EXECUTED
return RTEMS_INVALID_NAME;
}
disk_begin = dd->start;
*disk_end = dd->size;
24418: e593201c ldr r2, [r3, #28] <== NOT EXECUTED
/* Get disk begin, end and block size */
dd = rtems_disk_obtain( *disk);
if (dd == NULL) {
return RTEMS_INVALID_NAME;
}
disk_begin = dd->start;
2441c: e5936018 ldr r6, [r3, #24] <== NOT EXECUTED
*disk_end = dd->size;
24420: e5852000 str r2, [r5] <== NOT EXECUTED
block_size = dd->block_size;
24424: e5934020 ldr r4, [r3, #32] <== NOT EXECUTED
sc = rtems_disk_release( dd);
24428: ebff897f bl 6a2c <rtems_disk_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
2442c: e3500000 cmp r0, #0 <== NOT EXECUTED 24430: 1afffff0 bne 243f8 <rtems_bdpart_get_disk_data+0x24> <== NOT EXECUTED
return sc;
}
/* Check block size */
if (block_size < RTEMS_BDPART_BLOCK_SIZE) {
24434: e3540c02 cmp r4, #512 ; 0x200 <== NOT EXECUTED 24438: 3a000001 bcc 24444 <rtems_bdpart_get_disk_data+0x70> <== NOT EXECUTED
return RTEMS_IO_ERROR;
}
/* Check that we have do not have a logical disk */
if (disk_begin != 0) {
2443c: e3560000 cmp r6, #0 <== NOT EXECUTED 24440: 0affffec beq 243f8 <rtems_bdpart_get_disk_data+0x24> <== NOT EXECUTED 24444: e3a0001b mov r0, #27 <== NOT EXECUTED 24448: eaffffea b 243f8 <rtems_bdpart_get_disk_data+0x24> <== NOT EXECUTED
000241a0 <rtems_bdpart_mount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
241a0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL; const char *disk_file_name = strrchr( disk_name, '/');
241a4: e3a0102f mov r1, #47 ; 0x2f <== NOT EXECUTED
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
241a8: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 241ac: e1a09003 mov r9, r3 <== NOT EXECUTED 241b0: e1a08002 mov r8, r2 <== NOT EXECUTED 241b4: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL; const char *disk_file_name = strrchr( disk_name, '/');
241b8: eb0099d5 bl 4a914 <strrchr> <== NOT EXECUTED 241bc: e1a05000 mov r5, r0 <== NOT EXECUTED
char *logical_disk_name = NULL; char *logical_disk_marker = NULL; char *mount_point = NULL; char *mount_marker = NULL; size_t disk_file_name_size = 0; size_t disk_name_size = strlen( disk_name);
241c0: e1a00004 mov r0, r4 <== NOT EXECUTED 241c4: eb009686 bl 49be4 <strlen> <== NOT EXECUTED 241c8: e1a06000 mov r6, r0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
241cc: e1a00009 mov r0, r9 <== NOT EXECUTED 241d0: eb009683 bl 49be4 <strlen> <== NOT EXECUTED 241d4: e1a0a000 mov sl, r0 <== NOT EXECUTED
size_t i = 0;
/* Create logical disk name base */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
241d8: e2860004 add r0, r6, #4 <== NOT EXECUTED 241dc: ebff90a7 bl 8480 <malloc> <== NOT EXECUTED
if (logical_disk_name == NULL) {
241e0: e2507000 subs r7, r0, #0 <== NOT EXECUTED 241e4: 03a0401a moveq r4, #26 <== NOT EXECUTED 241e8: 0a000047 beq 2430c <rtems_bdpart_mount+0x16c> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
241ec: e1a01004 mov r1, r4 <== NOT EXECUTED 241f0: e1a02006 mov r2, r6 <== NOT EXECUTED 241f4: eb00971a bl 49e64 <strncpy> <== NOT EXECUTED
/* Get disk file name */
if (disk_file_name != NULL) {
241f8: e3550000 cmp r5, #0 <== NOT EXECUTED 241fc: 058d4004 streq r4, [sp, #4] <== NOT EXECUTED 24200: 01a0b006 moveq fp, r6 <== NOT EXECUTED 24204: 0a000004 beq 2421c <rtems_bdpart_mount+0x7c> <== NOT EXECUTED
disk_file_name += 1;
24208: e2855001 add r5, r5, #1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
2420c: e1a00005 mov r0, r5 <== NOT EXECUTED
}
strncpy( logical_disk_name, disk_name, disk_name_size);
/* Get disk file name */
if (disk_file_name != NULL) {
disk_file_name += 1;
24210: e58d5004 str r5, [sp, #4] <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
24214: eb009672 bl 49be4 <strlen> <== NOT EXECUTED 24218: e1a0b000 mov fp, r0 <== NOT EXECUTED
disk_file_name = disk_name;
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
2421c: e08b400a add r4, fp, sl <== NOT EXECUTED 24220: e2840005 add r0, r4, #5 <== NOT EXECUTED 24224: ebff9095 bl 8480 <malloc> <== NOT EXECUTED
if (mount_point == NULL) {
24228: e2505000 subs r5, r0, #0 <== NOT EXECUTED 2422c: 03a0401a moveq r4, #26 <== NOT EXECUTED 24230: 0a000031 beq 242fc <rtems_bdpart_mount+0x15c> <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
24234: e1a0200a mov r2, sl <== NOT EXECUTED 24238: e1a01009 mov r1, r9 <== NOT EXECUTED 2423c: eb009708 bl 49e64 <strncpy> <== NOT EXECUTED
mount_point [mount_base_size] = '/';
24240: e3a0302f mov r3, #47 ; 0x2f <== NOT EXECUTED 24244: e7c5300a strb r3, [r5, sl] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
24248: e28a0001 add r0, sl, #1 <== NOT EXECUTED 2424c: e0850000 add r0, r5, r0 <== NOT EXECUTED 24250: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 24254: e1a0200b mov r2, fp <== NOT EXECUTED 24258: eb009701 bl 49e64 <strncpy> <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
2425c: e284a001 add sl, r4, #1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
24260: e3580000 cmp r8, #0 <== NOT EXECUTED
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
24264: e0876006 add r6, r7, r6 <== NOT EXECUTED
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
24268: e085a00a add sl, r5, sl <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
2426c: 0a000021 beq 242f8 <rtems_bdpart_mount+0x158> <== NOT EXECUTED 24270: e3a04000 mov r4, #0 <== NOT EXECUTED 24274: ea000001 b 24280 <rtems_bdpart_mount+0xe0> <== NOT EXECUTED 24278: e1580004 cmp r8, r4 <== NOT EXECUTED 2427c: 9a00001d bls 242f8 <rtems_bdpart_mount+0x158> <== NOT EXECUTED
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
24280: e2844001 add r4, r4, #1 <== NOT EXECUTED 24284: e3a01004 mov r1, #4 <== NOT EXECUTED 24288: e59f20b8 ldr r2, [pc, #184] ; 24348 <rtems_bdpart_mount+0x1a8><== NOT EXECUTED 2428c: e1a03004 mov r3, r4 <== NOT EXECUTED 24290: e1a00006 mov r0, r6 <== NOT EXECUTED 24294: eb009240 bl 48b9c <snprintf> <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
24298: e3500003 cmp r0, #3 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
2429c: e3a02004 mov r2, #4 <== NOT EXECUTED 242a0: e1a01006 mov r1, r6 <== NOT EXECUTED 242a4: e1a0000a mov r0, sl <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
242a8: ca00001a bgt 24318 <rtems_bdpart_mount+0x178> <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
242ac: eb0096ec bl 49e64 <strncpy> <== NOT EXECUTED
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
242b0: e3a01f7f mov r1, #508 ; 0x1fc <== NOT EXECUTED 242b4: e2811003 add r1, r1, #3 <== NOT EXECUTED 242b8: e1a00005 mov r0, r5 <== NOT EXECUTED 242bc: ebff9473 bl 9490 <rtems_mkdir> <== NOT EXECUTED
if (rv != 0) {
242c0: e250c000 subs ip, r0, #0 <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
242c4: e1a01005 mov r1, r5 <== NOT EXECUTED 242c8: e59f207c ldr r2, [pc, #124] ; 2434c <rtems_bdpart_mount+0x1ac><== NOT EXECUTED 242cc: e1a0300c mov r3, ip <== NOT EXECUTED 242d0: e1a00007 mov r0, r7 <== NOT EXECUTED
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv != 0) {
242d4: 1a000015 bne 24330 <rtems_bdpart_mount+0x190> <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Mount */
rv = mount(
242d8: e58dc000 str ip, [sp] <== NOT EXECUTED 242dc: ebff9158 bl 8844 <mount> <== NOT EXECUTED
mount_point,
"msdos",
0,
NULL
);
if (rv != 0) {
242e0: e3500000 cmp r0, #0 <== NOT EXECUTED 242e4: 0affffe3 beq 24278 <rtems_bdpart_mount+0xd8> <== NOT EXECUTED
rmdir( mount_point);
242e8: e1a00005 mov r0, r5 <== NOT EXECUTED 242ec: eb001913 bl 2a740 <rmdir> <== NOT EXECUTED
/* Markers */
logical_disk_marker = logical_disk_name + disk_name_size;
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
242f0: e1580004 cmp r8, r4 <== NOT EXECUTED 242f4: 8affffe1 bhi 24280 <rtems_bdpart_mount+0xe0> <== NOT EXECUTED 242f8: e3a04000 mov r4, #0 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
242fc: e1a00007 mov r0, r7 <== NOT EXECUTED 24300: ebff8e9a bl 7d70 <free> <== NOT EXECUTED
free( mount_point);
24304: e1a00005 mov r0, r5 <== NOT EXECUTED 24308: ebff8e98 bl 7d70 <free> <== NOT EXECUTED
return esc;
}
2430c: e1a00004 mov r0, r4 <== NOT EXECUTED
24310: e28dd008 add sp, sp, #8 <== NOT EXECUTED
24314: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
24318: e1a00007 mov r0, r7 <== NOT EXECUTED 2431c: ebff8e93 bl 7d70 <free> <== NOT EXECUTED
free( mount_point);
24320: e1a00005 mov r0, r5 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create logical disk name */
int rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
24324: e3a04003 mov r4, #3 <== NOT EXECUTED
}
cleanup:
free( logical_disk_name);
free( mount_point);
24328: ebff8e90 bl 7d70 <free> <== NOT EXECUTED 2432c: eafffff6 b 2430c <rtems_bdpart_mount+0x16c> <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
24330: e1a00007 mov r0, r7 <== NOT EXECUTED 24334: ebff8e8d bl 7d70 <free> <== NOT EXECUTED
free( mount_point);
24338: e1a00005 mov r0, r5 <== NOT EXECUTED
}
/* Create mount point */
strncpy( mount_marker, logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE);
rv = rtems_mkdir( mount_point, S_IRWXU | S_IRWXG | S_IRWXO);
if (rv != 0) {
2433c: e3a0401b mov r4, #27 <== NOT EXECUTED
}
cleanup:
free( logical_disk_name);
free( mount_point);
24340: ebff8e8a bl 7d70 <free> <== NOT EXECUTED 24344: eafffff0 b 2430c <rtems_bdpart_mount+0x16c> <== NOT EXECUTED
00024824 <rtems_bdpart_new_record>:
static rtems_status_code rtems_bdpart_new_record(
dev_t disk,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
24824: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
24828: e1a04003 mov r4, r3 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
2482c: e5933000 ldr r3, [r3] <== NOT EXECUTED 24830: e3530000 cmp r3, #0 <== NOT EXECUTED
static rtems_status_code rtems_bdpart_new_record(
dev_t disk,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
24834: e1a06002 mov r6, r2 <== NOT EXECUTED 24838: e1a07000 mov r7, r0 <== NOT EXECUTED 2483c: e1a08001 mov r8, r1 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Synchronize previous block if necessary */
if (*block != NULL) {
24840: 0a000003 beq 24854 <rtems_bdpart_new_record+0x30> <== NOT EXECUTED
sc = rtems_bdbuf_sync( *block);
24844: e1a00003 mov r0, r3 <== NOT EXECUTED 24848: ebff818f bl 4e8c <rtems_bdbuf_sync> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
2484c: e2505000 subs r5, r0, #0 <== NOT EXECUTED 24850: 1a000016 bne 248b0 <rtems_bdpart_new_record+0x8c> <== NOT EXECUTED
return sc;
}
}
/* Read the new record block (this accounts for disk block sizes > 512) */
sc = rtems_bdbuf_read( disk, index, block);
24854: e1a00007 mov r0, r7 <== NOT EXECUTED 24858: e1a01008 mov r1, r8 <== NOT EXECUTED 2485c: e1a02006 mov r2, r6 <== NOT EXECUTED 24860: e1a03004 mov r3, r4 <== NOT EXECUTED 24864: ebff83a3 bl 56f8 <rtems_bdbuf_read> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
24868: e2505000 subs r5, r0, #0 <== NOT EXECUTED 2486c: 1a00000f bne 248b0 <rtems_bdpart_new_record+0x8c> <== NOT EXECUTED
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
24870: e5943000 ldr r3, [r4] <== NOT EXECUTED 24874: e3530000 cmp r3, #0 <== NOT EXECUTED 24878: 03a05009 moveq r5, #9 <== NOT EXECUTED 2487c: 0a00000b beq 248b0 <rtems_bdpart_new_record+0x8c> <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
/* Clear record */
memset( (*block)->buffer, 0, RTEMS_BDPART_BLOCK_SIZE);
24880: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 24884: e3a02c02 mov r2, #512 ; 0x200 <== NOT EXECUTED 24888: e1a01005 mov r1, r5 <== NOT EXECUTED 2488c: eb00870e bl 464cc <memset> <== NOT EXECUTED
/* Write signature */
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0] =
24890: e5943000 ldr r3, [r4] <== NOT EXECUTED 24894: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 24898: e3a02055 mov r2, #85 ; 0x55 <== NOT EXECUTED 2489c: e5c321fe strb r2, [r3, #510] ; 0x1fe <== NOT EXECUTED
RTEMS_BDPART_MBR_SIGNATURE_0;
(*block)->buffer [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_1] =
248a0: e5943000 ldr r3, [r4] <== NOT EXECUTED 248a4: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 248a8: e3e02055 mvn r2, #85 ; 0x55 <== NOT EXECUTED 248ac: e5c321ff strb r2, [r3, #511] ; 0x1ff <== NOT EXECUTED
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
248b0: e1a00005 mov r0, r5 <== NOT EXECUTED
248b4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00024590 <rtems_bdpart_read>:
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
24590: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_status_code esc = RTEMS_SUCCESSFUL; rtems_bdbuf_buffer *block = NULL; rtems_bdpart_partition *p = pt - 1; const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
24594: e2535000 subs r5, r3, #0 <== NOT EXECUTED 24598: 15957000 ldrne r7, [r5] <== NOT EXECUTED 2459c: 10877087 addne r7, r7, r7, lsl #1 <== NOT EXECUTED 245a0: 01a07005 moveq r7, r5 <== NOT EXECUTED 245a4: 11a07207 lslne r7, r7, #4 <== NOT EXECUTED
dev_t disk = 0;
size_t i = 0;
const uint8_t *data = NULL;
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
245a8: e3510000 cmp r1, #0 <== NOT EXECUTED 245ac: 13520000 cmpne r2, #0 <== NOT EXECUTED
const char *disk_name,
rtems_bdpart_format *format,
rtems_bdpart_partition *pt,
size_t *count
)
{
245b0: e24dd01c sub sp, sp, #28 <== NOT EXECUTED 245b4: e1a06001 mov r6, r1 <== NOT EXECUTED 245b8: e1a04002 mov r4, r2 <== NOT EXECUTED
dev_t disk = 0;
size_t i = 0;
const uint8_t *data = NULL;
/* Check parameter */
if (format == NULL || pt == NULL || count == NULL) {
245bc: 13a03000 movne r3, #0 <== NOT EXECUTED 245c0: 03a03001 moveq r3, #1 <== NOT EXECUTED 245c4: 0a00001e beq 24644 <rtems_bdpart_read+0xb4> <== NOT EXECUTED 245c8: e3550000 cmp r5, #0 <== NOT EXECUTED 245cc: 0a00001c beq 24644 <rtems_bdpart_read+0xb4> <== NOT EXECUTED
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
245d0: e242c030 sub ip, r2, #48 ; 0x30 <== NOT EXECUTED
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0); rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */ rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */ rtems_blkdev_bnum disk_end = 0;
245d4: e58d300c str r3, [sp, #12] <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_status_code esc = RTEMS_SUCCESSFUL; rtems_bdbuf_buffer *block = NULL; rtems_bdpart_partition *p = pt - 1; const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0); rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */
245d8: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
/* Set count to a save value */
*count = 0;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
245dc: e28d1004 add r1, sp, #4 <== NOT EXECUTED
if (format == NULL || pt == NULL || count == NULL) {
return RTEMS_INVALID_ADDRESS;
}
/* Set count to a save value */
*count = 0;
245e0: e5853000 str r3, [r5] <== NOT EXECUTED
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
245e4: e28d200c add r2, sp, #12 <== NOT EXECUTED
rtems_bdpart_partition *p = pt - 1; const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0); rtems_blkdev_bnum ep_begin = 0; /* Extended partition begin */ rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */ rtems_blkdev_bnum disk_end = 0; dev_t disk = 0;
245e8: e3a08000 mov r8, #0 <== NOT EXECUTED
245ec: e3a09000 mov r9, #0 <== NOT EXECUTED
245f0: e98d0300 stmib sp, {r8, r9} <== NOT EXECUTED
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
245f4: e58dc014 str ip, [sp, #20] <== NOT EXECUTED
size_t *count
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
245f8: e58d3018 str r3, [sp, #24] <== NOT EXECUTED
/* Set count to a save value */
*count = 0;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
245fc: ebffff74 bl 243d4 <rtems_bdpart_get_disk_data> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
24600: e3500000 cmp r0, #0 <== NOT EXECUTED 24604: 0a000001 beq 24610 <rtems_bdpart_read+0x80> <== NOT EXECUTED
if (block != NULL) {
rtems_bdbuf_release( block);
}
return esc;
}
24608: e28dd01c add sp, sp, #28 <== NOT EXECUTED
2460c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Read MBR */
sc = rtems_bdpart_read_record( disk, 0, &block);
24610: e28d8018 add r8, sp, #24 <== NOT EXECUTED
24614: e1a02000 mov r2, r0 <== NOT EXECUTED
24618: e1a03008 mov r3, r8 <== NOT EXECUTED
2461c: e99d0003 ldmib sp, {r0, r1} <== NOT EXECUTED
24620: ebffff4a bl 24350 <rtems_bdpart_read_record> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
24624: e3500000 cmp r0, #0 <== NOT EXECUTED 24628: 0a000007 beq 2464c <rtems_bdpart_read+0xbc> <== NOT EXECUTED
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
&p,
p_end,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
2462c: e1a04000 mov r4, r0 <== NOT EXECUTED 24630: e59d0018 ldr r0, [sp, #24] <== NOT EXECUTED
/* Return partition count */
*count = (size_t) (p - pt + 1);
cleanup:
if (block != NULL) {
24634: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_bdbuf_release( block);
24638: 1bff7f9d blne 44b4 <rtems_bdbuf_release> <== NOT EXECUTED 2463c: e1a00004 mov r0, r4 <== NOT EXECUTED 24640: eafffff0 b 24608 <rtems_bdpart_read+0x78> <== NOT EXECUTED 24644: e3a00009 mov r0, #9 <== NOT EXECUTED 24648: eaffffee b 24608 <rtems_bdpart_read+0x78> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
2464c: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 24650: e593c020 ldr ip, [r3, #32] <== NOT EXECUTED 24654: e28caf6f add sl, ip, #444 ; 0x1bc <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
rtems_bdbuf_buffer *block = NULL;
rtems_bdpart_partition *p = pt - 1;
const rtems_bdpart_partition *p_end = pt + (count != NULL ? *count : 0);
24658: e0849007 add r9, r4, r7 <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Read the first partition entry */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
2465c: e28aa002 add sl, sl, #2 <== NOT EXECUTED
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
24660: e28d7014 add r7, sp, #20 <== NOT EXECUTED 24664: e28db010 add fp, sp, #16 <== NOT EXECUTED 24668: e1a0000a mov r0, sl <== NOT EXECUTED 2466c: e1a01007 mov r1, r7 <== NOT EXECUTED 24670: e1a02009 mov r2, r9 <== NOT EXECUTED 24674: e1a0300b mov r3, fp <== NOT EXECUTED 24678: e58dc000 str ip, [sp] <== NOT EXECUTED 2467c: ebffff82 bl 2448c <rtems_bdpart_read_mbr_partition> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
24680: e3500000 cmp r0, #0 <== NOT EXECUTED 24684: e59dc000 ldr ip, [sp] <== NOT EXECUTED 24688: 1affffe7 bne 2462c <rtems_bdpart_read+0x9c> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Determine if we have a MBR or GPT format */
if (rtems_bdpart_mbr_partition_type( p->type) == RTEMS_BDPART_MBR_GPT) {
2468c: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 24690: e5d33008 ldrb r3, [r3, #8] <== NOT EXECUTED 24694: e35300ee cmp r3, #238 ; 0xee <== NOT EXECUTED 24698: 0a00005b beq 2480c <rtems_bdpart_read+0x27c> <== NOT EXECUTED
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
format->mbr.disk_id = rtems_uint32_from_little_endian(
2469c: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
esc = RTEMS_NOT_IMPLEMENTED;
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
246a0: e5860000 str r0, [r6] <== NOT EXECUTED
format->mbr.disk_id = rtems_uint32_from_little_endian(
246a4: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 246a8: e5d321ba ldrb r2, [r3, #442] ; 0x1ba <== NOT EXECUTED 246ac: e5d301bb ldrb r0, [r3, #443] ; 0x1bb <== NOT EXECUTED 246b0: e5d311b9 ldrb r1, [r3, #441] ; 0x1b9 <== NOT EXECUTED 246b4: e0820400 add r0, r2, r0, lsl #8 <== NOT EXECUTED 246b8: e5d321b8 ldrb r2, [r3, #440] ; 0x1b8 <== NOT EXECUTED 246bc: e0813400 add r3, r1, r0, lsl #8 <== NOT EXECUTED 246c0: e0823403 add r3, r2, r3, lsl #8 <== NOT EXECUTED
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
246c4: e3a02001 mov r2, #1 <== NOT EXECUTED 246c8: e5c62008 strb r2, [r6, #8] <== NOT EXECUTED
goto cleanup;
}
/* Set format */
format->type = RTEMS_BDPART_FORMAT_MBR;
format->mbr.disk_id = rtems_uint32_from_little_endian(
246cc: e5863004 str r3, [r6, #4] <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_read(
246d0: e28c6f7b add r6, ip, #492 ; 0x1ec <== NOT EXECUTED 246d4: e2866002 add r6, r6, #2 <== NOT EXECUTED
);
format->mbr.dos_compatibility = true;
/* Iterate through the rest of the primary partition table */
for (i = 1; i < 4; ++i) {
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
246d8: e28aa010 add sl, sl, #16 <== NOT EXECUTED
sc = rtems_bdpart_read_mbr_partition( data, &p, p_end, &ep_begin);
246dc: e1a0000a mov r0, sl <== NOT EXECUTED 246e0: e1a01007 mov r1, r7 <== NOT EXECUTED 246e4: e1a02009 mov r2, r9 <== NOT EXECUTED 246e8: e1a0300b mov r3, fp <== NOT EXECUTED 246ec: ebffff66 bl 2448c <rtems_bdpart_read_mbr_partition> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
246f0: e3500000 cmp r0, #0 <== NOT EXECUTED 246f4: 1affffcc bne 2462c <rtems_bdpart_read+0x9c> <== NOT EXECUTED
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
format->mbr.dos_compatibility = true;
/* Iterate through the rest of the primary partition table */
for (i = 1; i < 4; ++i) {
246f8: e15a0006 cmp sl, r6 <== NOT EXECUTED 246fc: 1afffff5 bne 246d8 <rtems_bdpart_read+0x148> <== NOT EXECUTED
goto cleanup;
}
}
/* Iterate through the logical partitions within the extended partition */
ebr = ep_begin;
24700: e59d6010 ldr r6, [sp, #16] <== NOT EXECUTED
while (ebr != 0) {
24704: e3560000 cmp r6, #0 <== NOT EXECUTED 24708: 059d2014 ldreq r2, [sp, #20] <== NOT EXECUTED 2470c: 059d3018 ldreq r3, [sp, #24] <== NOT EXECUTED 24710: 0a000029 beq 247bc <rtems_bdpart_read+0x22c> <== NOT EXECUTED
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( disk, ebr, &block);
24714: e1a02006 mov r2, r6 <== NOT EXECUTED
24718: e99d0003 ldmib sp, {r0, r1} <== NOT EXECUTED
2471c: e1a03008 mov r3, r8 <== NOT EXECUTED
24720: ebffff0a bl 24350 <rtems_bdpart_read_record> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
24724: e3500000 cmp r0, #0 <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
24728: e1a01007 mov r1, r7 <== NOT EXECUTED 2472c: e1a02009 mov r2, r9 <== NOT EXECUTED 24730: e1a03000 mov r3, r0 <== NOT EXECUTED
while (ebr != 0) {
rtems_blkdev_bnum tmp = 0;
/* Read EBR */
sc = rtems_bdpart_read_record( disk, ebr, &block);
if (sc != RTEMS_SUCCESSFUL) {
24734: 1affffbc bne 2462c <rtems_bdpart_read+0x9c> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Read first partition entry */
sc = rtems_bdpart_read_mbr_partition(
24738: e59d0018 ldr r0, [sp, #24] <== NOT EXECUTED 2473c: e5900020 ldr r0, [r0, #32] <== NOT EXECUTED 24740: e2800f6f add r0, r0, #444 ; 0x1bc <== NOT EXECUTED 24744: e2800002 add r0, r0, #2 <== NOT EXECUTED 24748: ebffff4f bl 2448c <rtems_bdpart_read_mbr_partition> <== NOT EXECUTED
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
&p,
p_end,
NULL
);
if (sc != RTEMS_SUCCESSFUL) {
2474c: e3500000 cmp r0, #0 <== NOT EXECUTED 24750: 1affffb5 bne 2462c <rtems_bdpart_read+0x9c> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Adjust partition begin */
tmp = p->begin + ebr;
24754: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 24758: e5923000 ldr r3, [r2] <== NOT EXECUTED 2475c: e0861003 add r1, r6, r3 <== NOT EXECUTED
if (tmp > p->begin) {
24760: e1530001 cmp r3, r1 <== NOT EXECUTED 24764: 2a00002b bcs 24818 <rtems_bdpart_read+0x288> <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
24768: e5923004 ldr r3, [r2, #4] <== NOT EXECUTED 2476c: e0866003 add r6, r6, r3 <== NOT EXECUTED
if (tmp > p->end) {
24770: e1530006 cmp r3, r6 <== NOT EXECUTED
}
/* Adjust partition begin */
tmp = p->begin + ebr;
if (tmp > p->begin) {
p->begin = tmp;
24774: e5821000 str r1, [r2] <== NOT EXECUTED
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
if (tmp > p->end) {
24778: 2a000026 bcs 24818 <rtems_bdpart_read+0x288> <== NOT EXECUTED
goto cleanup;
}
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
2477c: e59d0018 ldr r0, [sp, #24] <== NOT EXECUTED
esc = RTEMS_IO_ERROR;
goto cleanup;
}
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
24780: e5901020 ldr r1, [r0, #32] <== NOT EXECUTED
}
/* Adjust partition end */
tmp = p->end + ebr;
if (tmp > p->end) {
p->end = tmp;
24784: e5826004 str r6, [r2, #4] <== NOT EXECUTED
}
static rtems_blkdev_bnum rtems_bdpart_next_ebr( const uint8_t *data)
{
rtems_blkdev_bnum begin =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
24788: e2813f75 add r3, r1, #468 ; 0x1d4 <== NOT EXECUTED 2478c: e2833002 add r3, r3, #2 <== NOT EXECUTED 24790: e5d36003 ldrb r6, [r3, #3] <== NOT EXECUTED 24794: e5d3c002 ldrb ip, [r3, #2] <== NOT EXECUTED 24798: e5d3a001 ldrb sl, [r3, #1] <== NOT EXECUTED
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EXTENDED) {
2479c: e5d131d2 ldrb r3, [r1, #466] ; 0x1d2 <== NOT EXECUTED 247a0: e08cc406 add ip, ip, r6, lsl #8 <== NOT EXECUTED 247a4: e5d111d6 ldrb r1, [r1, #470] ; 0x1d6 <== NOT EXECUTED 247a8: e08aa40c add sl, sl, ip, lsl #8 <== NOT EXECUTED 247ac: e3530005 cmp r3, #5 <== NOT EXECUTED 247b0: e081a40a add sl, r1, sl, lsl #8 <== NOT EXECUTED
goto cleanup;
}
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
247b4: e1a03000 mov r3, r0 <== NOT EXECUTED
{
rtems_blkdev_bnum begin =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EXTENDED) {
247b8: 0a00000b beq 247ec <rtems_bdpart_read+0x25c> <== NOT EXECUTED
}
}
}
/* Return partition count */
*count = (size_t) (p - pt + 1);
247bc: e0642002 rsb r2, r4, r2 <== NOT EXECUTED 247c0: e1a02242 asr r2, r2, #4 <== NOT EXECUTED 247c4: e0821102 add r1, r2, r2, lsl #2 <== NOT EXECUTED 247c8: e0811201 add r1, r1, r1, lsl #4 <== NOT EXECUTED 247cc: e0811401 add r1, r1, r1, lsl #8 <== NOT EXECUTED 247d0: e0811801 add r1, r1, r1, lsl #16 <== NOT EXECUTED 247d4: e0822081 add r2, r2, r1, lsl #1 <== NOT EXECUTED 247d8: e2822001 add r2, r2, #1 <== NOT EXECUTED 247dc: e5852000 str r2, [r5] <== NOT EXECUTED 247e0: e1a00003 mov r0, r3 <== NOT EXECUTED 247e4: e3a04000 mov r4, #0 <== NOT EXECUTED 247e8: eaffff91 b 24634 <rtems_bdpart_read+0xa4> <== NOT EXECUTED
/* Read second partition entry for next EBR block */
ebr = rtems_bdpart_next_ebr(
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_1
);
if (ebr != 0) {
247ec: e35a0000 cmp sl, #0 <== NOT EXECUTED 247f0: 0afffff1 beq 247bc <rtems_bdpart_read+0x22c> <== NOT EXECUTED
/* Adjust partition EBR block index */
tmp = ebr + ep_begin;
247f4: e59d6010 ldr r6, [sp, #16] <== NOT EXECUTED 247f8: e08a6006 add r6, sl, r6 <== NOT EXECUTED
if (tmp > ebr) {
247fc: e156000a cmp r6, sl <== NOT EXECUTED 24800: 8affffc3 bhi 24714 <rtems_bdpart_read+0x184> <== NOT EXECUTED 24804: e3a0401b mov r4, #27 <== NOT EXECUTED 24808: eaffff89 b 24634 <rtems_bdpart_read+0xa4> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Determine if we have a MBR or GPT format */
if (rtems_bdpart_mbr_partition_type( p->type) == RTEMS_BDPART_MBR_GPT) {
2480c: e59d0018 ldr r0, [sp, #24] <== NOT EXECUTED 24810: e3a04018 mov r4, #24 <== NOT EXECUTED 24814: eaffff86 b 24634 <rtems_bdpart_read+0xa4> <== NOT EXECUTED
goto cleanup;
}
/* Adjust partition end */
tmp = p->end + ebr;
if (tmp > p->end) {
24818: e59d0018 ldr r0, [sp, #24] <== NOT EXECUTED 2481c: e3a0401b mov r4, #27 <== NOT EXECUTED 24820: eaffff83 b 24634 <rtems_bdpart_read+0xa4> <== NOT EXECUTED
0002448c <rtems_bdpart_read_mbr_partition>:
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
2448c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
rtems_blkdev_bnum begin =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
24490: e280c008 add ip, r0, #8 <== NOT EXECUTED
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
24494: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_blkdev_bnum begin =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_blkdev_bnum size =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
24498: e280000c add r0, r0, #12 <== NOT EXECUTED
{
uint32_t value = 0;
ssize_t i = 0;
for (i = 3; i >= 0; --i) {
value = (value << 8) + data [i];
2449c: e5dc7003 ldrb r7, [ip, #3] <== NOT EXECUTED 244a0: e5d08002 ldrb r8, [r0, #2] <== NOT EXECUTED 244a4: e5dc6002 ldrb r6, [ip, #2] <== NOT EXECUTED 244a8: e5d05003 ldrb r5, [r0, #3] <== NOT EXECUTED 244ac: e5dca001 ldrb sl, [ip, #1] <== NOT EXECUTED 244b0: e5d09001 ldrb r9, [r0, #1] <== NOT EXECUTED
rtems_blkdev_bnum end = begin + size; uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
244b4: e5d40004 ldrb r0, [r4, #4] <== NOT EXECUTED 244b8: e0866407 add r6, r6, r7, lsl #8 <== NOT EXECUTED 244bc: e0885405 add r5, r8, r5, lsl #8 <== NOT EXECUTED 244c0: e5d47008 ldrb r7, [r4, #8] <== NOT EXECUTED 244c4: e5d4c00c ldrb ip, [r4, #12] <== NOT EXECUTED 244c8: e08a6406 add r6, sl, r6, lsl #8 <== NOT EXECUTED 244cc: e0895405 add r5, r9, r5, lsl #8 <== NOT EXECUTED
if (type == RTEMS_BDPART_MBR_EMPTY) {
244d0: e3500000 cmp r0, #0 <== NOT EXECUTED 244d4: e0876406 add r6, r7, r6, lsl #8 <== NOT EXECUTED 244d8: e08c5405 add r5, ip, r5, lsl #8 <== NOT EXECUTED
const uint8_t *data,
rtems_bdpart_partition **p,
const rtems_bdpart_partition *p_end,
rtems_blkdev_bnum *ep_begin
)
{
244dc: e1a08001 mov r8, r1 <== NOT EXECUTED
rtems_blkdev_bnum size =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
uint8_t type = data [RTEMS_BDPART_MBR_OFFSET_TYPE];
if (type == RTEMS_BDPART_MBR_EMPTY) {
244e0: 0a000028 beq 24588 <rtems_bdpart_read_mbr_partition+0xfc> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
244e4: e5911000 ldr r1, [r1] <== NOT EXECUTED
244e8: e1510002 cmp r1, r2 <== NOT EXECUTED
244ec: 03a00005 moveq r0, #5 <== NOT EXECUTED
244f0: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
{
rtems_blkdev_bnum begin =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_blkdev_bnum size =
rtems_uint32_from_little_endian( data + RTEMS_BDPART_MBR_OFFSET_SIZE);
rtems_blkdev_bnum end = begin + size;
244f4: e0865005 add r5, r6, r5 <== NOT EXECUTED
if (type == RTEMS_BDPART_MBR_EMPTY) {
return RTEMS_SUCCESSFUL;
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
244f8: e1550006 cmp r5, r6 <== NOT EXECUTED
244fc: 93a0001b movls r0, #27 <== NOT EXECUTED
24500: 98bd87f0 popls {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
return RTEMS_IO_ERROR;
} else if (type == RTEMS_BDPART_MBR_EXTENDED) {
24504: e3500005 cmp r0, #5 <== NOT EXECUTED 24508: 0a00001a beq 24578 <rtems_bdpart_read_mbr_partition+0xec> <== NOT EXECUTED
} else {
/* Increment partition index */
++(*p);
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
2450c: e3a07000 mov r7, #0 <== NOT EXECUTED
if (ep_begin != NULL) {
*ep_begin = begin;
}
} else {
/* Increment partition index */
++(*p);
24510: e2813030 add r3, r1, #48 ; 0x30 <== NOT EXECUTED 24514: e5883000 str r3, [r8] <== NOT EXECUTED
/* Clear partition */
memset( *p, 0, sizeof( rtems_bdpart_partition));
24518: e581705c str r7, [r1, #92] ; 0x5c <== NOT EXECUTED 2451c: e5817030 str r7, [r1, #48] ; 0x30 <== NOT EXECUTED 24520: e5817034 str r7, [r1, #52] ; 0x34 <== NOT EXECUTED 24524: e5817038 str r7, [r1, #56] ; 0x38 <== NOT EXECUTED 24528: e581703c str r7, [r1, #60] ; 0x3c <== NOT EXECUTED 2452c: e5817040 str r7, [r1, #64] ; 0x40 <== NOT EXECUTED 24530: e5817044 str r7, [r1, #68] ; 0x44 <== NOT EXECUTED 24534: e5817048 str r7, [r1, #72] ; 0x48 <== NOT EXECUTED 24538: e581704c str r7, [r1, #76] ; 0x4c <== NOT EXECUTED 2453c: e5817050 str r7, [r1, #80] ; 0x50 <== NOT EXECUTED 24540: e5817054 str r7, [r1, #84] ; 0x54 <== NOT EXECUTED 24544: e5817058 str r7, [r1, #88] ; 0x58 <== NOT EXECUTED
/* Set values */
(*p)->begin = begin;
24548: e5981000 ldr r1, [r8] <== NOT EXECUTED 2454c: e5816000 str r6, [r1] <== NOT EXECUTED
(*p)->end = end;
24550: e5815004 str r5, [r1, #4] <== NOT EXECUTED
rtems_bdpart_to_partition_type( type, (*p)->type);
24554: e2811008 add r1, r1, #8 <== NOT EXECUTED 24558: ebffffc5 bl 24474 <rtems_bdpart_to_partition_type> <== NOT EXECUTED
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
2455c: e5983000 ldr r3, [r8] <== NOT EXECUTED
24560: e5d41000 ldrb r1, [r4] <== NOT EXECUTED
24564: e3a02000 mov r2, #0 <== NOT EXECUTED
24568: e1a00007 mov r0, r7 <== NOT EXECUTED
2456c: e5831028 str r1, [r3, #40] ; 0x28 <== NOT EXECUTED
24570: e583202c str r2, [r3, #44] ; 0x2c <== NOT EXECUTED
24574: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
return RTEMS_IO_ERROR;
} else if (type == RTEMS_BDPART_MBR_EXTENDED) {
if (ep_begin != NULL) {
24578: e3530000 cmp r3, #0 <== NOT EXECUTED
*ep_begin = begin;
2457c: 15836000 strne r6, [r3] <== NOT EXECUTED 24580: 13a00000 movne r0, #0 <== NOT EXECUTED
} else if (*p == p_end) {
return RTEMS_TOO_MANY;
} else if (begin >= end) {
return RTEMS_IO_ERROR;
} else if (type == RTEMS_BDPART_MBR_EXTENDED) {
if (ep_begin != NULL) {
24584: 18bd87f0 popne {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
/* Set values */
(*p)->begin = begin;
(*p)->end = end;
rtems_bdpart_to_partition_type( type, (*p)->type);
(*p)->flags = data [RTEMS_BDPART_MBR_OFFSET_FLAGS];
24588: e3a00000 mov r0, #0 <== NOT EXECUTED
}
return RTEMS_SUCCESSFUL;
}
2458c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
00024350 <rtems_bdpart_read_record>:
static rtems_status_code rtems_bdpart_read_record(
dev_t disk,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
24350: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
24354: e1a04003 mov r4, r3 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
24358: e5933000 ldr r3, [r3] <== NOT EXECUTED 2435c: e3530000 cmp r3, #0 <== NOT EXECUTED
static rtems_status_code rtems_bdpart_read_record(
dev_t disk,
rtems_blkdev_bnum index,
rtems_bdbuf_buffer **block
)
{
24360: e1a05002 mov r5, r2 <== NOT EXECUTED 24364: e1a06000 mov r6, r0 <== NOT EXECUTED 24368: e1a07001 mov r7, r1 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
/* Release previous block if necessary */
if (*block != NULL) {
2436c: 0a000003 beq 24380 <rtems_bdpart_read_record+0x30> <== NOT EXECUTED
sc = rtems_bdbuf_release( *block);
24370: e1a00003 mov r0, r3 <== NOT EXECUTED 24374: ebff804e bl 44b4 <rtems_bdbuf_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
24378: e3500000 cmp r0, #0 <== NOT EXECUTED
2437c: 18bd80f0 popne {r4, r5, r6, r7, pc} <== NOT EXECUTED
return sc;
}
}
/* Read the record block */
sc = rtems_bdbuf_read( disk, index, block);
24380: e1a00006 mov r0, r6 <== NOT EXECUTED 24384: e1a01007 mov r1, r7 <== NOT EXECUTED 24388: e1a02005 mov r2, r5 <== NOT EXECUTED 2438c: e1a03004 mov r3, r4 <== NOT EXECUTED 24390: ebff84d8 bl 56f8 <rtems_bdbuf_read> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
24394: e3500000 cmp r0, #0 <== NOT EXECUTED
24398: 18bd80f0 popne {r4, r5, r6, r7, pc} <== NOT EXECUTED
return sc;
}
/* just in case block did not get filled in */
if ( *block == NULL ) {
2439c: e5943000 ldr r3, [r4] <== NOT EXECUTED
243a0: e3530000 cmp r3, #0 <== NOT EXECUTED
243a4: 03a00009 moveq r0, #9 <== NOT EXECUTED
243a8: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
return RTEMS_INVALID_ADDRESS;
}
/* Check MBR signature */
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
243ac: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
static bool rtems_bdpart_is_valid_record( const uint8_t *data)
{
return data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0]
243b0: e5d321fe ldrb r2, [r3, #510] ; 0x1fe <== NOT EXECUTED 243b4: e3520055 cmp r2, #85 ; 0x55 <== NOT EXECUTED 243b8: 0a000001 beq 243c4 <rtems_bdpart_read_record+0x74> <== NOT EXECUTED 243bc: e3a0001b mov r0, #27 <== NOT EXECUTED
if (!rtems_bdpart_is_valid_record( (*block)->buffer)) {
return RTEMS_IO_ERROR;
}
return RTEMS_SUCCESSFUL;
}
243c0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
}
static bool rtems_bdpart_is_valid_record( const uint8_t *data)
{
return data [RTEMS_BDPART_MBR_OFFSET_SIGNATURE_0]
243c4: e5d331ff ldrb r3, [r3, #511] ; 0x1ff <== NOT EXECUTED
243c8: e35300aa cmp r3, #170 ; 0xaa <== NOT EXECUTED
243cc: 1afffffa bne 243bc <rtems_bdpart_read_record+0x6c> <== NOT EXECUTED
243d0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00005a90 <rtems_bdpart_register>:
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
5a90: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_status_code esc = RTEMS_SUCCESSFUL; rtems_device_major_number major = 0; rtems_device_minor_number minor = 0; rtems_blkdev_bnum disk_end = 0;
5a94: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
5a98: e24dd024 sub sp, sp, #36 ; 0x24 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_status_code esc = RTEMS_SUCCESSFUL; rtems_device_major_number major = 0; rtems_device_minor_number minor = 0; rtems_blkdev_bnum disk_end = 0;
5a9c: e58d3020 str r3, [sp, #32] <== NOT EXECUTED
dev_t disk = 0;
5aa0: e3a04000 mov r4, #0 <== NOT EXECUTED
5aa4: e3a03000 mov r3, #0 <== NOT EXECUTED
5aa8: e58d3018 str r3, [sp, #24] <== NOT EXECUTED
5aac: e58d401c str r4, [sp, #28] <== NOT EXECUTED
rtems_status_code rtems_bdpart_register(
const char *disk_name,
const rtems_bdpart_partition *pt,
size_t count
)
{
5ab0: e1a05000 mov r5, r0 <== NOT EXECUTED
5ab4: e1a0b001 mov fp, r1 <== NOT EXECUTED
5ab8: e1a07002 mov r7, r2 <== NOT EXECUTED
rtems_blkdev_bnum disk_end = 0; dev_t disk = 0; dev_t logical_disk = 0; char *logical_disk_name = NULL; char *logical_disk_marker = NULL; size_t disk_name_size = strlen( disk_name);
5abc: eb011048 bl 49be4 <strlen> <== NOT EXECUTED
size_t i = 0;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
5ac0: e28d1018 add r1, sp, #24 <== NOT EXECUTED
rtems_blkdev_bnum disk_end = 0; dev_t disk = 0; dev_t logical_disk = 0; char *logical_disk_name = NULL; char *logical_disk_marker = NULL; size_t disk_name_size = strlen( disk_name);
5ac4: e1a0a000 mov sl, r0 <== NOT EXECUTED
size_t i = 0;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
5ac8: e28d2020 add r2, sp, #32 <== NOT EXECUTED
5acc: e1a00005 mov r0, r5 <== NOT EXECUTED
5ad0: eb007a3f bl 243d4 <rtems_bdpart_get_disk_data> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
5ad4: e2504000 subs r4, r0, #0 <== NOT EXECUTED
5ad8: 0a000002 beq 5ae8 <rtems_bdpart_register+0x58> <== NOT EXECUTED
cleanup:
free( logical_disk_name);
return esc;
}
5adc: e1a00004 mov r0, r4 <== NOT EXECUTED
5ae0: e28dd024 add sp, sp, #36 ; 0x24 <== NOT EXECUTED
5ae4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create logical disk name */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
5ae8: e28a0004 add r0, sl, #4 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
5aec: e59d9018 ldr r9, [sp, #24] <== NOT EXECUTED
5af0: e59d601c ldr r6, [sp, #28] <== NOT EXECUTED
/* Create logical disk name */
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
5af4: eb000a61 bl 8480 <malloc> <== NOT EXECUTED
if (logical_disk_name == NULL) {
5af8: e2508000 subs r8, r0, #0 <== NOT EXECUTED
5afc: 03a0401a moveq r4, #26 <== NOT EXECUTED
5b00: 0afffff5 beq 5adc <rtems_bdpart_register+0x4c> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
5b04: e1a0200a mov r2, sl <== NOT EXECUTED
5b08: e1a01005 mov r1, r5 <== NOT EXECUTED
5b0c: eb0110d4 bl 49e64 <strncpy> <== NOT EXECUTED
logical_disk_marker = logical_disk_name + disk_name_size;
5b10: e088a00a add sl, r8, sl <== NOT EXECUTED
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
5b14: e3570000 cmp r7, #0 <== NOT EXECUTED
logical_disk_name = malloc( disk_name_size + RTEMS_BDPART_NUMBER_SIZE);
if (logical_disk_name == NULL) {
return RTEMS_NO_MEMORY;
}
strncpy( logical_disk_name, disk_name, disk_name_size);
logical_disk_marker = logical_disk_name + disk_name_size;
5b18: e58da00c str sl, [sp, #12] <== NOT EXECUTED
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
5b1c: 0a000022 beq 5bac <rtems_bdpart_register+0x11c> <== NOT EXECUTED
5b20: e1a0500b mov r5, fp <== NOT EXECUTED
5b24: ea00000d b 5b60 <rtems_bdpart_register+0xd0> <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
5b28: e5953000 ldr r3, [r5] <== NOT EXECUTED
5b2c: e58d3000 str r3, [sp] <== NOT EXECUTED
5b30: e595c004 ldr ip, [r5, #4] <== NOT EXECUTED
5b34: e063c00c rsb ip, r3, ip <== NOT EXECUTED
5b38: e28d3018 add r3, sp, #24 <== NOT EXECUTED
5b3c: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
5b40: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
5b44: e58d8008 str r8, [sp, #8] <== NOT EXECUTED
5b48: eb000438 bl 6c30 <rtems_disk_create_log> <== NOT EXECUTED
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
5b4c: e3500000 cmp r0, #0 <== NOT EXECUTED
5b50: 1a000017 bne 5bb4 <rtems_bdpart_register+0x124> <== NOT EXECUTED
}
strncpy( logical_disk_name, disk_name, disk_name_size);
logical_disk_marker = logical_disk_name + disk_name_size;
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
5b54: e1570004 cmp r7, r4 <== NOT EXECUTED
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
5b58: e2855030 add r5, r5, #48 ; 0x30 <== NOT EXECUTED
}
strncpy( logical_disk_name, disk_name, disk_name_size);
logical_disk_marker = logical_disk_name + disk_name_size;
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
5b5c: 9a000012 bls 5bac <rtems_bdpart_register+0x11c> <== NOT EXECUTED
/* Create a new device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Set partition number for logical disk name */
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
5b60: e2844001 add r4, r4, #1 <== NOT EXECUTED
for (i = 0; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
int rv = 0;
/* New minor number */
++minor;
5b64: e2866001 add r6, r6, #1 <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
5b68: e58d9010 str r9, [sp, #16] <== NOT EXECUTED
temp.__overlay.minor = _minor;
5b6c: e58d6014 str r6, [sp, #20] <== NOT EXECUTED
/* Create a new device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Set partition number for logical disk name */
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
5b70: e3a01004 mov r1, #4 <== NOT EXECUTED
5b74: e59f2040 ldr r2, [pc, #64] ; 5bbc <rtems_bdpart_register+0x12c><== NOT EXECUTED
5b78: e1a03004 mov r3, r4 <== NOT EXECUTED
5b7c: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED
return temp.device;
5b80: e28db010 add fp, sp, #16 <== NOT EXECUTED
5b84: e89b0c00 ldm fp, {sl, fp} <== NOT EXECUTED
5b88: eb010c03 bl 48b9c <snprintf> <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
5b8c: e3500003 cmp r0, #3 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Create logical disk */
sc = rtems_disk_create_log(
5b90: e1a0100b mov r1, fp <== NOT EXECUTED
5b94: e1a0000a mov r0, sl <== NOT EXECUTED
/* Create a new device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Set partition number for logical disk name */
rv = snprintf( logical_disk_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
5b98: daffffe2 ble 5b28 <rtems_bdpart_register+0x98> <== NOT EXECUTED
5b9c: e3a04003 mov r4, #3 <== NOT EXECUTED
}
}
cleanup:
free( logical_disk_name);
5ba0: e1a00008 mov r0, r8 <== NOT EXECUTED
5ba4: eb000871 bl 7d70 <free> <== NOT EXECUTED
return esc;
5ba8: eaffffcb b 5adc <rtems_bdpart_register+0x4c> <== NOT EXECUTED
}
strncpy( logical_disk_name, disk_name, disk_name_size);
logical_disk_marker = logical_disk_name + disk_name_size;
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
5bac: e3a04000 mov r4, #0 <== NOT EXECUTED
5bb0: eafffffa b 5ba0 <rtems_bdpart_register+0x110> <== NOT EXECUTED
disk,
p->begin,
p->end - p->begin,
logical_disk_name
);
if (sc != RTEMS_SUCCESSFUL) {
5bb4: e1a04000 mov r4, r0 <== NOT EXECUTED
5bb8: eafffff8 b 5ba0 <rtems_bdpart_register+0x110> <== NOT EXECUTED
00005bc0 <rtems_bdpart_register_from_disk>:
return esc;
}
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
5bc0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
5bc4: e24ddfc6 sub sp, sp, #792 ; 0x318 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_bdpart_format format; rtems_bdpart_partition pt [RTEMS_BDPART_PARTITION_NUMBER_HINT]; size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;
5bc8: e3a0c010 mov ip, #16 <== NOT EXECUTED
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
5bcc: e28d1c03 add r1, sp, #768 ; 0x300 <== NOT EXECUTED
5bd0: e1a0200d mov r2, sp <== NOT EXECUTED
5bd4: e28d3fc5 add r3, sp, #788 ; 0x314 <== NOT EXECUTED
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_bdpart_format format;
rtems_bdpart_partition pt [RTEMS_BDPART_PARTITION_NUMBER_HINT];
size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;
5bd8: e58dc314 str ip, [sp, #788] ; 0x314 <== NOT EXECUTED
return esc;
}
rtems_status_code rtems_bdpart_register_from_disk( const char *disk_name)
{
5bdc: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_bdpart_format format;
rtems_bdpart_partition pt [RTEMS_BDPART_PARTITION_NUMBER_HINT];
size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
5be0: eb007a6a bl 24590 <rtems_bdpart_read> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
5be4: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_bdpart_format format;
rtems_bdpart_partition pt [RTEMS_BDPART_PARTITION_NUMBER_HINT];
size_t count = RTEMS_BDPART_PARTITION_NUMBER_HINT;
/* Read partitions */
sc = rtems_bdpart_read( disk_name, &format, pt, &count);
5be8: e1a0400d mov r4, sp <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Register partitions */
return rtems_bdpart_register( disk_name, pt, count);
5bec: 01a00005 moveq r0, r5 <== NOT EXECUTED
5bf0: 01a0100d moveq r1, sp <== NOT EXECUTED
5bf4: 059d2314 ldreq r2, [sp, #788] ; 0x314 <== NOT EXECUTED
5bf8: 0bffffa4 bleq 5a90 <rtems_bdpart_register> <== NOT EXECUTED
}
5bfc: e28ddfc6 add sp, sp, #792 ; 0x318 <== NOT EXECUTED
5c00: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
0002444c <rtems_bdpart_to_mbr_partition_type>:
bool rtems_bdpart_to_mbr_partition_type(
const uuid_t type,
uint8_t *mbr_type
)
{
2444c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
*mbr_type = rtems_bdpart_mbr_partition_type( type);
24450: e4d03001 ldrb r3, [r0], #1 <== NOT EXECUTED
return memcmp(
24454: e3a0200f mov r2, #15 <== NOT EXECUTED
bool rtems_bdpart_to_mbr_partition_type(
const uuid_t type,
uint8_t *mbr_type
)
{
*mbr_type = rtems_bdpart_mbr_partition_type( type);
24458: e5c13000 strb r3, [r1] <== NOT EXECUTED
return memcmp(
2445c: e59f100c ldr r1, [pc, #12] ; 24470 <rtems_bdpart_to_mbr_partition_type+0x24><== NOT EXECUTED 24460: eb008768 bl 46208 <memcmp> <== NOT EXECUTED
type + 1,
RTEMS_BDPART_MBR_MASTER_TYPE + 1,
sizeof( uuid_t) - 1
) == 0;
}
24464: e2700001 rsbs r0, r0, #1 <== NOT EXECUTED
24468: 33a00000 movcc r0, #0 <== NOT EXECUTED
2446c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00024474 <rtems_bdpart_to_partition_type>:
static const uuid_t RTEMS_BDPART_MBR_MASTER_TYPE =
RTEMS_BDPART_MBR_PARTITION_TYPE( RTEMS_BDPART_MBR_EMPTY);
void rtems_bdpart_to_partition_type( uint8_t mbr_type, uuid_t type)
{
type [0] = mbr_type;
24474: e4c10001 strb r0, [r1], #1 <== NOT EXECUTED
memcpy( type + 1, RTEMS_BDPART_MBR_MASTER_TYPE + 1, sizeof( uuid_t) - 1);
24478: e1a00001 mov r0, r1 <== NOT EXECUTED 2447c: e59f1004 ldr r1, [pc, #4] ; 24488 <rtems_bdpart_to_partition_type+0x14><== NOT EXECUTED 24480: e3a0200f mov r2, #15 <== NOT EXECUTED 24484: ea008789 b 462b0 <memcpy> <== NOT EXECUTED
00024074 <rtems_bdpart_unmount>:
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
24074: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL; const char *disk_file_name = strrchr( disk_name, '/');
24078: e3a0102f mov r1, #47 ; 0x2f <== NOT EXECUTED
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count,
const char *mount_base
)
{
2407c: e1a09003 mov r9, r3 <== NOT EXECUTED 24080: e1a06002 mov r6, r2 <== NOT EXECUTED 24084: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL; const char *disk_file_name = strrchr( disk_name, '/');
24088: eb009a21 bl 4a914 <strrchr> <== NOT EXECUTED 2408c: e1a05000 mov r5, r0 <== NOT EXECUTED
char *mount_point = NULL; char *mount_marker = NULL; size_t disk_file_name_size = 0; size_t disk_name_size = strlen( disk_name);
24090: e1a00004 mov r0, r4 <== NOT EXECUTED 24094: eb0096d2 bl 49be4 <strlen> <== NOT EXECUTED 24098: e1a0a000 mov sl, r0 <== NOT EXECUTED
size_t mount_base_size = strlen( mount_base);
2409c: e1a00009 mov r0, r9 <== NOT EXECUTED 240a0: eb0096cf bl 49be4 <strlen> <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
240a4: e3550000 cmp r5, #0 <== NOT EXECUTED
const char *disk_file_name = strrchr( disk_name, '/'); char *mount_point = NULL; char *mount_marker = NULL; size_t disk_file_name_size = 0; size_t disk_name_size = strlen( disk_name); size_t mount_base_size = strlen( mount_base);
240a8: e1a07000 mov r7, r0 <== NOT EXECUTED
size_t i = 0;
/* Get disk file name */
if (disk_file_name != NULL) {
240ac: 0a000003 beq 240c0 <rtems_bdpart_unmount+0x4c> <== NOT EXECUTED
disk_file_name += 1;
240b0: e2854001 add r4, r5, #1 <== NOT EXECUTED
disk_file_name_size = strlen( disk_file_name);
240b4: e1a00004 mov r0, r4 <== NOT EXECUTED 240b8: eb0096c9 bl 49be4 <strlen> <== NOT EXECUTED 240bc: e1a0a000 mov sl, r0 <== NOT EXECUTED
disk_file_name = disk_name;
disk_file_name_size = disk_name_size;
}
/* Create mount point base */
mount_point = malloc( mount_base_size + 1 + disk_file_name_size + RTEMS_BDPART_NUMBER_SIZE);
240c0: e08a8007 add r8, sl, r7 <== NOT EXECUTED 240c4: e2880005 add r0, r8, #5 <== NOT EXECUTED 240c8: ebff90ec bl 8480 <malloc> <== NOT EXECUTED
if (mount_point == NULL) {
240cc: e2505000 subs r5, r0, #0 <== NOT EXECUTED 240d0: 03a0401a moveq r4, #26 <== NOT EXECUTED 240d4: 0a000022 beq 24164 <rtems_bdpart_unmount+0xf0> <== NOT EXECUTED
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
240d8: e1a02007 mov r2, r7 <== NOT EXECUTED 240dc: e1a01009 mov r1, r9 <== NOT EXECUTED 240e0: eb00975f bl 49e64 <strncpy> <== NOT EXECUTED
mount_point [mount_base_size] = '/'; strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
240e4: e2870001 add r0, r7, #1 <== NOT EXECUTED
if (mount_point == NULL) {
esc = RTEMS_NO_MEMORY;
goto cleanup;
}
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
240e8: e3a0302f mov r3, #47 ; 0x2f <== NOT EXECUTED 240ec: e7c53007 strb r3, [r5, r7] <== NOT EXECUTED
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
240f0: e0850000 add r0, r5, r0 <== NOT EXECUTED 240f4: e1a01004 mov r1, r4 <== NOT EXECUTED 240f8: e1a0200a mov r2, sl <== NOT EXECUTED 240fc: eb009758 bl 49e64 <strncpy> <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
24100: e2887001 add r7, r8, #1 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
24104: e3560000 cmp r6, #0 <== NOT EXECUTED
strncpy( mount_point, mount_base, mount_base_size);
mount_point [mount_base_size] = '/';
strncpy( mount_point + mount_base_size + 1, disk_file_name, disk_file_name_size);
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
24108: e0857007 add r7, r5, r7 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
2410c: 0a000018 beq 24174 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED 24110: e3a04000 mov r4, #0 <== NOT EXECUTED 24114: ea000001 b 24120 <rtems_bdpart_unmount+0xac> <== NOT EXECUTED 24118: e1560004 cmp r6, r4 <== NOT EXECUTED 2411c: 9a000014 bls 24174 <rtems_bdpart_unmount+0x100> <== NOT EXECUTED
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
24120: e2844001 add r4, r4, #1 <== NOT EXECUTED 24124: e3a01004 mov r1, #4 <== NOT EXECUTED 24128: e59f206c ldr r2, [pc, #108] ; 2419c <rtems_bdpart_unmount+0x128><== NOT EXECUTED 2412c: e1a03004 mov r3, r4 <== NOT EXECUTED 24130: e1a00007 mov r0, r7 <== NOT EXECUTED 24134: eb009298 bl 48b9c <snprintf> <== NOT EXECUTED
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
24138: e3500003 cmp r0, #3 <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
2413c: e1a00005 mov r0, r5 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
24140: ca000010 bgt 24188 <rtems_bdpart_unmount+0x114> <== NOT EXECUTED
esc = RTEMS_INVALID_NAME;
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
24144: eb001ab8 bl 2ac2c <unmount> <== NOT EXECUTED
if (rv == 0) {
24148: e3500000 cmp r0, #0 <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
2414c: e1a00005 mov r0, r5 <== NOT EXECUTED
goto cleanup;
}
/* Unmount */
rv = unmount( mount_point);
if (rv == 0) {
24150: 1afffff0 bne 24118 <rtems_bdpart_unmount+0xa4> <== NOT EXECUTED
/* Remove mount point */
rv = rmdir( mount_point);
24154: eb001979 bl 2a740 <rmdir> <== NOT EXECUTED
if (rv != 0) {
24158: e3500000 cmp r0, #0 <== NOT EXECUTED 2415c: 0affffed beq 24118 <rtems_bdpart_unmount+0xa4> <== NOT EXECUTED 24160: e3a0401b mov r4, #27 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
24164: e1a00005 mov r0, r5 <== NOT EXECUTED 24168: ebff8f00 bl 7d70 <free> <== NOT EXECUTED
return esc;
}
2416c: e1a00004 mov r0, r4 <== NOT EXECUTED
24170: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
24174: e1a00005 mov r0, r5 <== NOT EXECUTED
/* Marker */
mount_marker = mount_point + mount_base_size + 1 + disk_file_name_size;
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
24178: e3a04000 mov r4, #0 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
2417c: ebff8efb bl 7d70 <free> <== NOT EXECUTED
return esc;
}
24180: e1a00004 mov r0, r4 <== NOT EXECUTED
24184: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
24188: e1a00005 mov r0, r5 <== NOT EXECUTED
/* Mount supported file systems for each partition */
for (i = 0; i < count; ++i) {
/* Create mount point */
int rv = snprintf( mount_marker, RTEMS_BDPART_NUMBER_SIZE, "%zu", i + 1);
if (rv >= RTEMS_BDPART_NUMBER_SIZE) {
2418c: e3a04003 mov r4, #3 <== NOT EXECUTED
}
}
cleanup:
free( mount_point);
24190: ebff8ef6 bl 7d70 <free> <== NOT EXECUTED
return esc;
}
24194: e1a00004 mov r0, r4 <== NOT EXECUTED
24198: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
00005a10 <rtems_bdpart_unregister>:
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
5a10: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
5a14: e24dd014 sub sp, sp, #20 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_device_major_number major = 0; rtems_device_minor_number minor = 0; rtems_blkdev_bnum disk_end = 0;
5a18: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_status_code rtems_bdpart_unregister(
const char *disk_name,
const rtems_bdpart_partition *pt __attribute__((unused)),
size_t count
)
{
5a1c: e1a04002 mov r4, r2 <== NOT EXECUTED
dev_t disk = 0;
dev_t logical_disk = 0;
size_t i = 0;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
5a20: e28d1008 add r1, sp, #8 <== NOT EXECUTED
5a24: e28d2010 add r2, sp, #16 <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_blkdev_bnum disk_end = 0;
dev_t disk = 0;
5a28: e3a05000 mov r5, #0 <== NOT EXECUTED
5a2c: e3a06000 mov r6, #0 <== NOT EXECUTED
)
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
rtems_blkdev_bnum disk_end = 0;
5a30: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
dev_t disk = 0;
5a34: e58d5008 str r5, [sp, #8] <== NOT EXECUTED
5a38: e58d600c str r6, [sp, #12] <== NOT EXECUTED
dev_t logical_disk = 0;
size_t i = 0;
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
5a3c: eb007a64 bl 243d4 <rtems_bdpart_get_disk_data> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
5a40: e3500000 cmp r0, #0 <== NOT EXECUTED
5a44: 1a00000f bne 5a88 <rtems_bdpart_unregister+0x78> <== NOT EXECUTED
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
5a48: e3540000 cmp r4, #0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
5a4c: e59d7008 ldr r7, [sp, #8] <== NOT EXECUTED
5a50: e59d500c ldr r5, [sp, #12] <== NOT EXECUTED
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
5a54: 0a00000b beq 5a88 <rtems_bdpart_unregister+0x78> <== NOT EXECUTED
5a58: e1a06000 mov r6, r0 <== NOT EXECUTED
5a5c: ea000001 b 5a68 <rtems_bdpart_unregister+0x58> <== NOT EXECUTED
5a60: e1540006 cmp r4, r6 <== NOT EXECUTED
5a64: 9a000007 bls 5a88 <rtems_bdpart_unregister+0x78> <== NOT EXECUTED
/* New minor number */
++minor;
5a68: e2855001 add r5, r5, #1 <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
5a6c: e58d7000 str r7, [sp] <== NOT EXECUTED
temp.__overlay.minor = _minor;
5a70: e58d5004 str r5, [sp, #4] <== NOT EXECUTED
/* Get the device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Delete logical disk */
sc = rtems_disk_delete( logical_disk);
5a74: e89d0003 ldm sp, {r0, r1} <== NOT EXECUTED
5a78: eb000373 bl 684c <rtems_disk_delete> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
5a7c: e3500000 cmp r0, #0 <== NOT EXECUTED
/* Get the disk device identifier */
rtems_filesystem_split_dev_t( disk, major, minor);
/* Create a logical disk for each partition */
for (i = 0; i < count; ++i) {
5a80: e2866001 add r6, r6, #1 <== NOT EXECUTED
/* Get the device identifier */
logical_disk = rtems_filesystem_make_dev_t( major, minor);
/* Delete logical disk */
sc = rtems_disk_delete( logical_disk);
if (sc != RTEMS_SUCCESSFUL) {
5a84: 0afffff5 beq 5a60 <rtems_bdpart_unregister+0x50> <== NOT EXECUTED
return sc;
}
}
return RTEMS_SUCCESSFUL;
}
5a88: e28dd014 add sp, sp, #20 <== NOT EXECUTED
5a8c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
000248b8 <rtems_bdpart_write>:
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
248b8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_status_code esc = RTEMS_SUCCESSFUL; bool dos_compatibility = format != NULL
248bc: e2515000 subs r5, r1, #0 <== NOT EXECUTED
const char *disk_name,
const rtems_bdpart_format *format,
const rtems_bdpart_partition *pt,
size_t count
)
{
248c0: e24dd034 sub sp, sp, #52 ; 0x34 <== NOT EXECUTED 248c4: e1a06002 mov r6, r2 <== NOT EXECUTED 248c8: e1a04003 mov r4, r3 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL; rtems_status_code esc = RTEMS_SUCCESSFUL; bool dos_compatibility = format != NULL
248cc: 0a000002 beq 248dc <rtems_bdpart_write+0x24> <== NOT EXECUTED
&& format->type == RTEMS_BDPART_FORMAT_MBR
248d0: e5953000 ldr r3, [r5] <== NOT EXECUTED 248d4: e3530000 cmp r3, #0 <== NOT EXECUTED 248d8: 0a00000b beq 2490c <rtems_bdpart_write+0x54> <== NOT EXECUTED
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
248dc: e3a0a000 mov sl, #0 <== NOT EXECUTED
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
/* Check if we have something to do */
if (count == 0) {
248e0: e3540000 cmp r4, #0 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
248e4: e58da02c str sl, [sp, #44] ; 0x2c <== NOT EXECUTED
rtems_blkdev_bnum disk_end = 0;
248e8: e58da028 str sl, [sp, #40] ; 0x28 <== NOT EXECUTED 248ec: e3a07001 mov r7, #1 <== NOT EXECUTED
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
/* Check if we have something to do */
if (count == 0) {
248f0: 0a00000e beq 24930 <rtems_bdpart_write+0x78> <== NOT EXECUTED
/* Nothing to do */
return RTEMS_SUCCESSFUL;
}
/* Check parameter */
if (format == NULL || pt == NULL) {
248f4: e3550000 cmp r5, #0 <== NOT EXECUTED 248f8: 13560000 cmpne r6, #0 <== NOT EXECUTED 248fc: 03a00009 moveq r0, #9 <== NOT EXECUTED 24900: 1a00000c bne 24938 <rtems_bdpart_write+0x80> <== NOT EXECUTED
if (block != NULL) {
rtems_bdbuf_sync( block);
}
return esc;
}
24904: e28dd034 add sp, sp, #52 ; 0x34 <== NOT EXECUTED
24908: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
{
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
2490c: e5d52008 ldrb r2, [r5, #8] <== NOT EXECUTED 24910: e3520000 cmp r2, #0 <== NOT EXECUTED 24914: 0afffff0 beq 248dc <rtems_bdpart_write+0x24> <== NOT EXECUTED
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
/* Check if we have something to do */
if (count == 0) {
24918: e3540000 cmp r4, #0 <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
2491c: e58d3028 str r3, [sp, #40] ; 0x28 <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
24920: e58d302c str r3, [sp, #44] ; 0x2c <== NOT EXECUTED
rtems_blkdev_bnum disk_end = 0;
24924: e3a0a001 mov sl, #1 <== NOT EXECUTED 24928: e3a0703f mov r7, #63 ; 0x3f <== NOT EXECUTED
size_t ppc = 0; /* Primary partition count */
size_t i = 0;
uint8_t *data = NULL;
/* Check if we have something to do */
if (count == 0) {
2492c: 1afffff0 bne 248f4 <rtems_bdpart_write+0x3c> <== NOT EXECUTED
}
cleanup:
if (block != NULL) {
rtems_bdbuf_sync( block);
24930: e1a00004 mov r0, r4 <== NOT EXECUTED 24934: eafffff2 b 24904 <rtems_bdpart_write+0x4c> <== NOT EXECUTED
if (format == NULL || pt == NULL) {
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
24938: e28d1020 add r1, sp, #32 <== NOT EXECUTED 2493c: e28d2028 add r2, sp, #40 ; 0x28 <== NOT EXECUTED
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
rtems_blkdev_bnum record_space =
dos_compatibility ? RTEMS_BDPART_MBR_CYLINDER_SIZE : 1;
dev_t disk = 0;
24940: e3a08000 mov r8, #0 <== NOT EXECUTED 24944: e3a09000 mov r9, #0 <== NOT EXECUTED 24948: e58d8020 str r8, [sp, #32] <== NOT EXECUTED 2494c: e58d9024 str r9, [sp, #36] ; 0x24 <== NOT EXECUTED
if (format == NULL || pt == NULL) {
return RTEMS_INVALID_ADDRESS;
}
/* Get disk data */
sc = rtems_bdpart_get_disk_data( disk_name, &disk, &disk_end);
24950: ebfffe9f bl 243d4 <rtems_bdpart_get_disk_data> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
24954: e3500000 cmp r0, #0 <== NOT EXECUTED 24958: 1affffe9 bne 24904 <rtems_bdpart_write+0x4c> <== NOT EXECUTED
return sc;
}
/* Align end of disk on cylinder boundary if necessary */
if (dos_compatibility) {
2495c: e35a0000 cmp sl, #0 <== NOT EXECUTED 24960: 059d0028 ldreq r0, [sp, #40] ; 0x28 <== NOT EXECUTED 24964: 0a000005 beq 24980 <rtems_bdpart_write+0xc8> <== NOT EXECUTED
disk_end -= (disk_end % record_space);
24968: e59d8028 ldr r8, [sp, #40] ; 0x28 <== NOT EXECUTED 2496c: e1a01007 mov r1, r7 <== NOT EXECUTED 24970: e1a00008 mov r0, r8 <== NOT EXECUTED 24974: eb00d9ef bl 5b138 <__umodsi3> <== NOT EXECUTED 24978: e0600008 rsb r0, r0, r8 <== NOT EXECUTED 2497c: e58d0028 str r0, [sp, #40] ; 0x28 <== NOT EXECUTED
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Check that begin and end are proper within the disk */
if (p->begin >= disk_end || p->end > disk_end) {
24980: e596b000 ldr fp, [r6] <== NOT EXECUTED 24984: e15b0000 cmp fp, r0 <== NOT EXECUTED 24988: 2a000053 bcs 24adc <rtems_bdpart_write+0x224> <== NOT EXECUTED 2498c: e5963004 ldr r3, [r6, #4] <== NOT EXECUTED 24990: e1530000 cmp r3, r0 <== NOT EXECUTED 24994: 8a000050 bhi 24adc <rtems_bdpart_write+0x224> <== NOT EXECUTED
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that begin and end are valid */
if (p->begin >= p->end) {
24998: e153000b cmp r3, fp <== NOT EXECUTED 2499c: 81a08006 movhi r8, r6 <== NOT EXECUTED 249a0: 81a03006 movhi r3, r6 <== NOT EXECUTED 249a4: 83a01000 movhi r1, #0 <== NOT EXECUTED 249a8: 8a00000c bhi 249e0 <rtems_bdpart_write+0x128> <== NOT EXECUTED 249ac: ea00004a b 24adc <rtems_bdpart_write+0x224> <== NOT EXECUTED
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Check that begin and end are proper within the disk */
if (p->begin >= disk_end || p->end > disk_end) {
249b0: e5932030 ldr r2, [r3, #48] ; 0x30 <== NOT EXECUTED 249b4: e1520000 cmp r2, r0 <== NOT EXECUTED 249b8: 2a000047 bcs 24adc <rtems_bdpart_write+0x224> <== NOT EXECUTED 249bc: e593c034 ldr ip, [r3, #52] ; 0x34 <== NOT EXECUTED 249c0: e15c0000 cmp ip, r0 <== NOT EXECUTED 249c4: 8a000044 bhi 24adc <rtems_bdpart_write+0x224> <== NOT EXECUTED
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that begin and end are valid */
if (p->begin >= p->end) {
249c8: e152000c cmp r2, ip <== NOT EXECUTED 249cc: 2a000042 bcs 24adc <rtems_bdpart_write+0x224> <== NOT EXECUTED
esc = RTEMS_INVALID_NUMBER;
goto cleanup;
}
/* Check that partitions do not overlap */
if (i > 0 && pt [i - 1].end > p->begin) {
249d0: e593c004 ldr ip, [r3, #4] <== NOT EXECUTED 249d4: e152000c cmp r2, ip <== NOT EXECUTED 249d8: 3a00003f bcc 24adc <rtems_bdpart_write+0x224> <== NOT EXECUTED 249dc: e2833030 add r3, r3, #48 ; 0x30 <== NOT EXECUTED
if (dos_compatibility) {
disk_end -= (disk_end % record_space);
}
/* Check that we have a consistent partition table */
for (i = 0; i < count; ++i) {
249e0: e2811001 add r1, r1, #1 <== NOT EXECUTED 249e4: e1540001 cmp r4, r1 <== NOT EXECUTED 249e8: 8afffff0 bhi 249b0 <rtems_bdpart_write+0xf8> <== NOT EXECUTED
goto cleanup;
}
}
/* Check format */
if (format->type != RTEMS_BDPART_FORMAT_MBR) {
249ec: e5953000 ldr r3, [r5] <== NOT EXECUTED 249f0: e3530000 cmp r3, #0 <== NOT EXECUTED 249f4: 13a04018 movne r4, #24 <== NOT EXECUTED 249f8: 1a000038 bne 24ae0 <rtems_bdpart_write+0x228> <== NOT EXECUTED
* Set primary partition count. If we have more than four partitions we need * an extended partition which will contain the partitions of number four and * above as logical partitions. If we have four or less partitions we can * use the primary partition table. */ ppc = count <= 4 ? count : 3;
249fc: e3540004 cmp r4, #4 <== NOT EXECUTED 24a00: 91a09004 movls r9, r4 <== NOT EXECUTED 24a04: 83a09003 movhi r9, #3 <== NOT EXECUTED
/*
* Check that the first primary partition starts at head one and sector one
* under the virtual one head and 63 sectors geometry if necessary.
*/
if (dos_compatibility && pt [0].begin != RTEMS_BDPART_MBR_CYLINDER_SIZE) {
24a08: e35a0000 cmp sl, #0 <== NOT EXECUTED 24a0c: 0a000001 beq 24a18 <rtems_bdpart_write+0x160> <== NOT EXECUTED 24a10: e35b003f cmp fp, #63 ; 0x3f <== NOT EXECUTED 24a14: 1a000030 bne 24adc <rtems_bdpart_write+0x224> <== NOT EXECUTED
* Each logical partition is described via one EBR preceding the partition.
* The space for the EBR and maybe some space which is needed for DOS
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
24a18: e1590004 cmp r9, r4 <== NOT EXECUTED 24a1c: 2a000018 bcs 24a84 <rtems_bdpart_write+0x1cc> <== NOT EXECUTED
if ((pt [i].begin - pt [i - 1].end) < record_space) {
24a20: e2493001 sub r3, r9, #1 <== NOT EXECUTED 24a24: e0832083 add r2, r3, r3, lsl #1 <== NOT EXECUTED 24a28: e0893089 add r3, r9, r9, lsl #1 <== NOT EXECUTED 24a2c: e1a03203 lsl r3, r3, #4 <== NOT EXECUTED 24a30: e0862202 add r2, r6, r2, lsl #4 <== NOT EXECUTED 24a34: e7961003 ldr r1, [r6, r3] <== NOT EXECUTED 24a38: e5922004 ldr r2, [r2, #4] <== NOT EXECUTED 24a3c: e0622001 rsb r2, r2, r1 <== NOT EXECUTED 24a40: e1570002 cmp r7, r2 <== NOT EXECUTED 24a44: e0862003 add r2, r6, r3 <== NOT EXECUTED 24a48: 8a000023 bhi 24adc <rtems_bdpart_write+0x224> <== NOT EXECUTED 24a4c: e2891001 add r1, r9, #1 <== NOT EXECUTED 24a50: e0811081 add r1, r1, r1, lsl #1 <== NOT EXECUTED 24a54: e0861201 add r1, r6, r1, lsl #4 <== NOT EXECUTED 24a58: e1a03009 mov r3, r9 <== NOT EXECUTED 24a5c: ea000005 b 24a78 <rtems_bdpart_write+0x1c0> <== NOT EXECUTED 24a60: e5920004 ldr r0, [r2, #4] <== NOT EXECUTED 24a64: e491c030 ldr ip, [r1], #48 ; 0x30 <== NOT EXECUTED 24a68: e060000c rsb r0, r0, ip <== NOT EXECUTED 24a6c: e1570000 cmp r7, r0 <== NOT EXECUTED 24a70: e2822030 add r2, r2, #48 ; 0x30 <== NOT EXECUTED 24a74: 8a000018 bhi 24adc <rtems_bdpart_write+0x224> <== NOT EXECUTED
* Each logical partition is described via one EBR preceding the partition.
* The space for the EBR and maybe some space which is needed for DOS
* compatibility resides between the partitions. So there have to be gaps of
* the appropriate size between the partitions.
*/
for (i = ppc; i < count; ++i) {
24a78: e2833001 add r3, r3, #1 <== NOT EXECUTED 24a7c: e1540003 cmp r4, r3 <== NOT EXECUTED 24a80: 8afffff6 bhi 24a60 <rtems_bdpart_write+0x1a8> <== NOT EXECUTED 24a84: e3a0b000 mov fp, #0 <== NOT EXECUTED 24a88: e1a0a006 mov sl, r6 <== NOT EXECUTED 24a8c: ea000008 b 24ab4 <rtems_bdpart_write+0x1fc> <== NOT EXECUTED
esc = RTEMS_INVALID_ID;
goto cleanup;
}
/* Check flags */
if (p->flags > 0xffU) {
24a90: e59a202c ldr r2, [sl, #44] ; 0x2c <== NOT EXECUTED 24a94: e3520000 cmp r2, #0 <== NOT EXECUTED 24a98: 1a00000d bne 24ad4 <rtems_bdpart_write+0x21c> <== NOT EXECUTED 24a9c: e59a3028 ldr r3, [sl, #40] ; 0x28 <== NOT EXECUTED 24aa0: e35300ff cmp r3, #255 ; 0xff <== NOT EXECUTED 24aa4: 8a00000a bhi 24ad4 <rtems_bdpart_write+0x21c> <== NOT EXECUTED
goto cleanup;
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
24aa8: e154000b cmp r4, fp <== NOT EXECUTED 24aac: e28aa030 add sl, sl, #48 ; 0x30 <== NOT EXECUTED 24ab0: 9a000010 bls 24af8 <rtems_bdpart_write+0x240> <== NOT EXECUTED
uint8_t type = 0;
24ab4: e3a02000 mov r2, #0 <== NOT EXECUTED
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
24ab8: e28a0008 add r0, sl, #8 <== NOT EXECUTED 24abc: e28d1033 add r1, sp, #51 ; 0x33 <== NOT EXECUTED
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
uint8_t type = 0;
24ac0: e5cd2033 strb r2, [sp, #51] ; 0x33 <== NOT EXECUTED
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
24ac4: ebfffe60 bl 2444c <rtems_bdpart_to_mbr_partition_type> <== NOT EXECUTED 24ac8: e3500000 cmp r0, #0 <== NOT EXECUTED
goto cleanup;
}
}
/* Check that we can convert the parition descriptions to the MBR format */
for (i = 0; i < count; ++i) {
24acc: e28bb001 add fp, fp, #1 <== NOT EXECUTED
uint8_t type = 0;
const rtems_bdpart_partition *p = pt + i;
/* Check type */
if (!rtems_bdpart_to_mbr_partition_type( p->type, &type)) {
24ad0: 1affffee bne 24a90 <rtems_bdpart_write+0x1d8> <== NOT EXECUTED
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
24ad4: e3a04004 mov r4, #4 <== NOT EXECUTED 24ad8: ea000000 b 24ae0 <rtems_bdpart_write+0x228> <== NOT EXECUTED 24adc: e3a0400a mov r4, #10 <== NOT EXECUTED
}
}
cleanup:
if (block != NULL) {
24ae0: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED 24ae4: e3500000 cmp r0, #0 <== NOT EXECUTED 24ae8: 0affff90 beq 24930 <rtems_bdpart_write+0x78> <== NOT EXECUTED
rtems_bdbuf_sync( block);
24aec: ebff80e6 bl 4e8c <rtems_bdbuf_sync> <== NOT EXECUTED 24af0: e1a00004 mov r0, r4 <== NOT EXECUTED 24af4: eaffff82 b 24904 <rtems_bdpart_write+0x4c> <== NOT EXECUTED
/* Check ID */
/* TODO */
}
/* New MBR */
sc = rtems_bdpart_new_record( disk, 0, &block);
24af8: e28d1020 add r1, sp, #32 <== NOT EXECUTED
24afc: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
24b00: e28d302c add r3, sp, #44 ; 0x2c <== NOT EXECUTED
24b04: ebffff46 bl 24824 <rtems_bdpart_new_record> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
24b08: e3500000 cmp r0, #0 <== NOT EXECUTED 24b0c: 1a0000b8 bne 24df4 <rtems_bdpart_write+0x53c> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Write disk ID */
rtems_uint32_to_little_endian(
24b10: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED 24b14: e5952004 ldr r2, [r5, #4] <== NOT EXECUTED 24b18: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
24b1c: e1a05c22 lsr r5, r2, #24 <== NOT EXECUTED
value >>= 8;
24b20: e1a0c422 lsr ip, r2, #8 <== NOT EXECUTED 24b24: e1a01822 lsr r1, r2, #16 <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
24b28: e5c351bb strb r5, [r3, #443] ; 0x1bb <== NOT EXECUTED 24b2c: e5c3c1b9 strb ip, [r3, #441] ; 0x1b9 <== NOT EXECUTED 24b30: e5c311ba strb r1, [r3, #442] ; 0x1ba <== NOT EXECUTED 24b34: e5c321b8 strb r2, [r3, #440] ; 0x1b8 <== NOT EXECUTED
format->mbr.disk_id,
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
24b38: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED 24b3c: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 24b40: e2835f6f add r5, r3, #444 ; 0x1bc <== NOT EXECUTED 24b44: e2855002 add r5, r5, #2 <== NOT EXECUTED 24b48: e58d5008 str r5, [sp, #8] <== NOT EXECUTED 24b4c: e58d9004 str r9, [sp, #4] <== NOT EXECUTED 24b50: e58d700c str r7, [sp, #12] <== NOT EXECUTED 24b54: e58d6010 str r6, [sp, #16] <== NOT EXECUTED 24b58: e58d4014 str r4, [sp, #20] <== NOT EXECUTED
for (i = 0; i < ppc; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
24b5c: e5982000 ldr r2, [r8] <== NOT EXECUTED 24b60: e5981004 ldr r1, [r8, #4] <== NOT EXECUTED
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
24b64: e59da004 ldr sl, [sp, #4] <== NOT EXECUTED
static inline uint8_t rtems_bdpart_mbr_partition_type(
const uuid_t type
)
{
return type [0];
24b68: e5d8c008 ldrb ip, [r8, #8] <== NOT EXECUTED
rtems_bdpart_write_mbr_partition(
data,
p->begin,
p->end - p->begin,
rtems_bdpart_mbr_partition_type( p->type),
(uint8_t) p->flags
24b6c: e598b028 ldr fp, [r8, #40] ; 0x28 <== NOT EXECUTED
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write partition entry */
rtems_bdpart_write_mbr_partition(
24b70: e0621001 rsb r1, r2, r1 <== NOT EXECUTED
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
24b74: e2800001 add r0, r0, #1 <== NOT EXECUTED 24b78: e1a04c21 lsr r4, r1, #24 <== NOT EXECUTED 24b7c: e15a0000 cmp sl, r0 <== NOT EXECUTED
value >>= 8;
24b80: e1a09422 lsr r9, r2, #8 <== NOT EXECUTED 24b84: e1a0a822 lsr sl, r2, #16 <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
24b88: e1a07c22 lsr r7, r2, #24 <== NOT EXECUTED
value >>= 8;
24b8c: e1a06421 lsr r6, r1, #8 <== NOT EXECUTED 24b90: e1a05821 lsr r5, r1, #16 <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
24b94: e5c391c7 strb r9, [r3, #455] ; 0x1c7 <== NOT EXECUTED 24b98: e5c3a1c8 strb sl, [r3, #456] ; 0x1c8 <== NOT EXECUTED 24b9c: e5c371c9 strb r7, [r3, #457] ; 0x1c9 <== NOT EXECUTED 24ba0: e5c361cb strb r6, [r3, #459] ; 0x1cb <== NOT EXECUTED 24ba4: e5c351cc strb r5, [r3, #460] ; 0x1cc <== NOT EXECUTED 24ba8: e5c341cd strb r4, [r3, #461] ; 0x1cd <== NOT EXECUTED
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
24bac: e5c3c1c2 strb ip, [r3, #450] ; 0x1c2 <== NOT EXECUTED
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
24bb0: e5c3b1be strb fp, [r3, #446] ; 0x1be <== NOT EXECUTED 24bb4: e5c321c6 strb r2, [r3, #454] ; 0x1c6 <== NOT EXECUTED 24bb8: e5c311ca strb r1, [r3, #458] ; 0x1ca <== NOT EXECUTED
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
24bbc: e2888030 add r8, r8, #48 ; 0x30 <== NOT EXECUTED 24bc0: e2833010 add r3, r3, #16 <== NOT EXECUTED 24bc4: 8affffe4 bhi 24b5c <rtems_bdpart_write+0x2a4> <== NOT EXECUTED 24bc8: e59d9004 ldr r9, [sp, #4] <== NOT EXECUTED 24bcc: e59d4014 ldr r4, [sp, #20] <== NOT EXECUTED 24bd0: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
24bd4: e1590004 cmp r9, r4 <== NOT EXECUTED 24bd8: e59d700c ldr r7, [sp, #12] <== NOT EXECUTED 24bdc: e59d6010 ldr r6, [sp, #16] <== NOT EXECUTED
block->buffer + RTEMS_BDPART_MBR_OFFSET_DISK_ID
);
/* Write primary partition table */
data = block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0;
for (i = 0; i < ppc; ++i) {
24be0: e0803209 add r3, r0, r9, lsl #4 <== NOT EXECUTED
data += RTEMS_BDPART_MBR_TABLE_ENTRY_SIZE;
}
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
24be4: 0a000084 beq 24dfc <rtems_bdpart_write+0x544> <== NOT EXECUTED
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
24be8: e3a00030 mov r0, #48 ; 0x30 <== NOT EXECUTED 24bec: e0050990 mul r5, r0, r9 <== NOT EXECUTED 24bf0: e7962005 ldr r2, [r6, r5] <== NOT EXECUTED 24bf4: e0672002 rsb r2, r7, r2 <== NOT EXECUTED 24bf8: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
/* Write extended partition */
rtems_bdpart_write_mbr_partition(
24bfc: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 24c00: e59d2028 ldr r2, [sp, #40] ; 0x28 <== NOT EXECUTED 24c04: e0612002 rsb r2, r1, r2 <== NOT EXECUTED
value >>= 8;
24c08: e59da004 ldr sl, [sp, #4] <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
24c0c: e1a08c22 lsr r8, r2, #24 <== NOT EXECUTED 24c10: e58d801c str r8, [sp, #28] <== NOT EXECUTED
value >>= 8;
24c14: e59d8004 ldr r8, [sp, #4] <== NOT EXECUTED 24c18: e1a0a42a lsr sl, sl, #8 <== NOT EXECUTED 24c1c: e58da018 str sl, [sp, #24] <== NOT EXECUTED 24c20: e1a08828 lsr r8, r8, #16 <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
24c24: e59da004 ldr sl, [sp, #4] <== NOT EXECUTED
value >>= 8;
24c28: e58d8014 str r8, [sp, #20] <== NOT EXECUTED 24c2c: e1a08422 lsr r8, r2, #8 <== NOT EXECUTED 24c30: e58d8010 str r8, [sp, #16] <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
24c34: e1a0ac2a lsr sl, sl, #24 <== NOT EXECUTED 24c38: e59d8004 ldr r8, [sp, #4] <== NOT EXECUTED 24c3c: e58da000 str sl, [sp] <== NOT EXECUTED
value >>= 8;
24c40: e1a0a822 lsr sl, r2, #16 <== NOT EXECUTED 24c44: e58da00c str sl, [sp, #12] <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
24c48: e5c38008 strb r8, [r3, #8] <== NOT EXECUTED 24c4c: e59d8000 ldr r8, [sp] <== NOT EXECUTED
uint32_t size,
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
24c50: e283c008 add ip, r3, #8 <== NOT EXECUTED 24c54: e5cc8003 strb r8, [ip, #3] <== NOT EXECUTED 24c58: e59d8018 ldr r8, [sp, #24] <== NOT EXECUTED 24c5c: e5cc8001 strb r8, [ip, #1] <== NOT EXECUTED 24c60: e59d8014 ldr r8, [sp, #20] <== NOT EXECUTED 24c64: e5cc8002 strb r8, [ip, #2] <== NOT EXECUTED 24c68: e5c3200c strb r2, [r3, #12] <== NOT EXECUTED 24c6c: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
24c70: e283100c add r1, r3, #12 <== NOT EXECUTED 24c74: e5c12003 strb r2, [r1, #3] <== NOT EXECUTED 24c78: e59d8010 ldr r8, [sp, #16] <== NOT EXECUTED 24c7c: e5c18001 strb r8, [r1, #1] <== NOT EXECUTED 24c80: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
24c84: e3a0b005 mov fp, #5 <== NOT EXECUTED 24c88: e5c12002 strb r2, [r1, #2] <== NOT EXECUTED 24c8c: e5c3b004 strb fp, [r3, #4] <== NOT EXECUTED
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
24c90: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 24c94: e3a0a000 mov sl, #0 <== NOT EXECUTED
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
24c98: e1a0800b mov r8, fp <== NOT EXECUTED
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
24c9c: e7c1a209 strb sl, [r1, r9, lsl #4] <== NOT EXECUTED
/* Write extended partition with logical partitions if necessary */
if (ppc != count) {
rtems_blkdev_bnum ebr = 0; /* Extended boot record block index */
/* Begin of extended partition */
rtems_blkdev_bnum ep_begin = pt [ppc].begin - record_space;
24ca0: e0865005 add r5, r6, r5 <== NOT EXECUTED
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
24ca4: 2a000054 bcs 24dfc <rtems_bdpart_write+0x544> <== NOT EXECUTED
rtems_status_code esc = RTEMS_SUCCESSFUL;
bool dos_compatibility = format != NULL
&& format->type == RTEMS_BDPART_FORMAT_MBR
&& format->mbr.dos_compatibility;
rtems_bdbuf_buffer *block = NULL;
rtems_blkdev_bnum disk_end = 0;
24ca8: e2893001 add r3, r9, #1 <== NOT EXECUTED 24cac: e58d9008 str r9, [sp, #8] <== NOT EXECUTED 24cb0: e0286390 mla r8, r0, r3, r6 <== NOT EXECUTED 24cb4: e1a0b004 mov fp, r4 <== NOT EXECUTED 24cb8: e1a06009 mov r6, r9 <== NOT EXECUTED
);
}
/* New EBR */
ebr = p->begin - record_space;
sc = rtems_bdpart_new_record( disk, ebr, &block);
24cbc: e5952000 ldr r2, [r5] <== NOT EXECUTED
24cc0: e28d1020 add r1, sp, #32 <== NOT EXECUTED
24cc4: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
24cc8: e0672002 rsb r2, r7, r2 <== NOT EXECUTED
24ccc: e28d302c add r3, sp, #44 ; 0x2c <== NOT EXECUTED
24cd0: ebfffed3 bl 24824 <rtems_bdpart_new_record> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) {
24cd4: e3500000 cmp r0, #0 <== NOT EXECUTED 24cd8: 1a000045 bne 24df4 <rtems_bdpart_write+0x53c> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
24cdc: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED 24ce0: e5931020 ldr r1, [r3, #32] <== NOT EXECUTED
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
record_space,
p->end - p->begin,
rtems_bdpart_mbr_partition_type( p->type),
(uint8_t) p->flags
24ce4: e5954028 ldr r4, [r5, #40] ; 0x28 <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
24ce8: e281cf6f add ip, r1, #444 ; 0x1bc <== NOT EXECUTED 24cec: e5959004 ldr r9, [r5, #4] <== NOT EXECUTED 24cf0: e595a000 ldr sl, [r5] <== NOT EXECUTED 24cf4: e5d55008 ldrb r5, [r5, #8] <== NOT EXECUTED
block->buffer + RTEMS_BDPART_MBR_OFFSET_TABLE_0,
record_space,
p->end - p->begin,
rtems_bdpart_mbr_partition_type( p->type),
(uint8_t) p->flags
24cf8: e1a03001 mov r3, r1 <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
24cfc: e28cc002 add ip, ip, #2 <== NOT EXECUTED
RTEMS_BDPART_MBR_SIGNATURE_1;
return RTEMS_SUCCESSFUL;
}
rtems_status_code rtems_bdpart_write(
24d00: e2810004 add r0, r1, #4 <== NOT EXECUTED 24d04: e1a02007 mov r2, r7 <== NOT EXECUTED 24d08: e5c321c6 strb r2, [r3, #454] ; 0x1c6 <== NOT EXECUTED 24d0c: e2833001 add r3, r3, #1 <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
24d10: e1530000 cmp r3, r0 <== NOT EXECUTED
data [i] = (uint8_t) value;
24d14: e3a02000 mov r2, #0 <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
24d18: 1afffffa bne 24d08 <rtems_bdpart_write+0x450> <== NOT EXECUTED
esc = sc;
goto cleanup;
}
/* Write first partition entry */
rtems_bdpart_write_mbr_partition(
24d1c: e06aa009 rsb sl, sl, r9 <== NOT EXECUTED
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
24d20: e2866001 add r6, r6, #1 <== NOT EXECUTED
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
24d24: e28cc00c add ip, ip, #12 <== NOT EXECUTED
data [i] = (uint8_t) value;
24d28: e1a00c2a lsr r0, sl, #24 <== NOT EXECUTED
value >>= 8;
24d2c: e1a0242a lsr r2, sl, #8 <== NOT EXECUTED 24d30: e1a0382a lsr r3, sl, #16 <== NOT EXECUTED
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
24d34: e15b0006 cmp fp, r6 <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
24d38: e5c1a1ca strb sl, [r1, #458] ; 0x1ca <== NOT EXECUTED 24d3c: e5cc0003 strb r0, [ip, #3] <== NOT EXECUTED 24d40: e5cc2001 strb r2, [ip, #1] <== NOT EXECUTED 24d44: e5cc3002 strb r3, [ip, #2] <== NOT EXECUTED
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
24d48: e5c141be strb r4, [r1, #446] ; 0x1be <== NOT EXECUTED
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
24d4c: e5c151c2 strb r5, [r1, #450] ; 0x1c2 <== NOT EXECUTED
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
24d50: 9a000029 bls 24dfc <rtems_bdpart_write+0x544> <== NOT EXECUTED
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
24d54: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 24d58: e1520006 cmp r2, r6 <== NOT EXECUTED
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
24d5c: e1a05008 mov r5, r8 <== NOT EXECUTED
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
24d60: 2a000021 bcs 24dec <rtems_bdpart_write+0x534> <== NOT EXECUTED
rtems_blkdev_bnum begin = p->begin - record_space;
rtems_bdpart_write_mbr_partition(
24d64: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED
for (i = ppc; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
rtems_blkdev_bnum begin = p->begin - record_space;
24d68: e5981000 ldr r1, [r8] <== NOT EXECUTED
rtems_bdpart_write_mbr_partition(
24d6c: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 24d70: e59d2028 ldr r2, [sp, #40] ; 0x28 <== NOT EXECUTED 24d74: e59da004 ldr sl, [sp, #4] <== NOT EXECUTED
for (i = ppc; i < count; ++i) {
const rtems_bdpart_partition *p = pt + i;
/* Write second partition entry */
if (i > ppc) {
rtems_blkdev_bnum begin = p->begin - record_space;
24d78: e0671001 rsb r1, r7, r1 <== NOT EXECUTED
rtems_bdpart_write_mbr_partition(
24d7c: e0612002 rsb r2, r1, r2 <== NOT EXECUTED 24d80: e283cf73 add ip, r3, #460 ; 0x1cc <== NOT EXECUTED 24d84: e06a1001 rsb r1, sl, r1 <== NOT EXECUTED 24d88: e1a0ec22 lsr lr, r2, #24 <== NOT EXECUTED 24d8c: e28cc002 add ip, ip, #2 <== NOT EXECUTED 24d90: e58de010 str lr, [sp, #16] <== NOT EXECUTED
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
24d94: e28c000c add r0, ip, #12 <== NOT EXECUTED 24d98: e1a0ac21 lsr sl, r1, #24 <== NOT EXECUTED
uint32_t size,
uint8_t type,
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
24d9c: e28cc008 add ip, ip, #8 <== NOT EXECUTED
value >>= 8;
24da0: e1a0e422 lsr lr, r2, #8 <== NOT EXECUTED 24da4: e1a04421 lsr r4, r1, #8 <== NOT EXECUTED 24da8: e1a09821 lsr r9, r1, #16 <== NOT EXECUTED 24dac: e58de00c str lr, [sp, #12] <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
24db0: e5c311d6 strb r1, [r3, #470] ; 0x1d6 <== NOT EXECUTED 24db4: e5cca003 strb sl, [ip, #3] <== NOT EXECUTED 24db8: e5cc4001 strb r4, [ip, #1] <== NOT EXECUTED 24dbc: e5cc9002 strb r9, [ip, #2] <== NOT EXECUTED 24dc0: e5c321da strb r2, [r3, #474] ; 0x1da <== NOT EXECUTED 24dc4: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 24dc8: e5c01003 strb r1, [r0, #3] <== NOT EXECUTED
value >>= 8;
24dcc: e1a0e822 lsr lr, r2, #16 <== NOT EXECUTED
static inline void rtems_uint32_to_little_endian( uint32_t value, uint8_t *data)
{
size_t i = 0;
for (i = 0; i < 4; ++i) {
data [i] = (uint8_t) value;
24dd0: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE); data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type; data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
24dd4: e3a0a000 mov sl, #0 <== NOT EXECUTED 24dd8: e5c0e002 strb lr, [r0, #2] <== NOT EXECUTED
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
24ddc: e3a0e005 mov lr, #5 <== NOT EXECUTED 24de0: e5c02001 strb r2, [r0, #1] <== NOT EXECUTED
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
24de4: e5c3a1ce strb sl, [r3, #462] ; 0x1ce <== NOT EXECUTED
uint8_t flags
)
{
rtems_uint32_to_little_endian( begin, data + RTEMS_BDPART_MBR_OFFSET_BEGIN);
rtems_uint32_to_little_endian( size, data + RTEMS_BDPART_MBR_OFFSET_SIZE);
data [RTEMS_BDPART_MBR_OFFSET_TYPE] = type;
24de8: e5c3e1d2 strb lr, [r3, #466] ; 0x1d2 <== NOT EXECUTED
data [RTEMS_BDPART_MBR_OFFSET_FLAGS] = flags;
24dec: e2888030 add r8, r8, #48 ; 0x30 <== NOT EXECUTED 24df0: eaffffb1 b 24cbc <rtems_bdpart_write+0x404> <== NOT EXECUTED
}
/* New EBR */
ebr = p->begin - record_space;
sc = rtems_bdpart_new_record( disk, ebr, &block);
if (sc != RTEMS_SUCCESSFUL) {
24df4: e1a04000 mov r4, r0 <== NOT EXECUTED 24df8: eaffff38 b 24ae0 <rtems_bdpart_write+0x228> <== NOT EXECUTED
RTEMS_BDPART_MBR_EXTENDED,
0
);
/* Write logical partitions */
for (i = ppc; i < count; ++i) {
24dfc: e3a04000 mov r4, #0 <== NOT EXECUTED 24e00: eaffff36 b 24ae0 <rtems_bdpart_write+0x228> <== NOT EXECUTED
0000cc20 <rtems_blkdev_generic_ioctl>:
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
int rc;
switch (args->command)
cc20: e3a03911 mov r3, #278528 ; 0x44000
cc24: e5921004 ldr r1, [r2, #4]
cc28: e2833c02 add r3, r3, #512 ; 0x200
cc2c: e283310d add r3, r3, #1073741827 ; 0x40000003
rtems_device_driver
rtems_blkdev_generic_ioctl(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
cc30: e92d4010 push {r4, lr}
cc34: e1a04002 mov r4, r2
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
cc38: e5922000 ldr r2, [r2]
int rc;
switch (args->command)
cc3c: e1510003 cmp r1, r3
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
cc40: e5923034 ldr r3, [r2, #52] ; 0x34
int rc;
switch (args->command)
cc44: 0a00003d beq cd40 <rtems_blkdev_generic_ioctl+0x120>
cc48: 9a000017 bls ccac <rtems_blkdev_generic_ioctl+0x8c>
cc4c: e3a02102 mov r2, #-2147483648 ; 0x80000000
cc50: e2822911 add r2, r2, #278528 ; 0x44000
cc54: e2822f81 add r2, r2, #516 ; 0x204
cc58: e1510002 cmp r1, r2
cc5c: 0a000022 beq ccec <rtems_blkdev_generic_ioctl+0xcc>
cc60: e3a02961 mov r2, #1589248 ; 0x184000 <== NOT EXECUTED
cc64: e2822c02 add r2, r2, #512 ; 0x200 <== NOT EXECUTED
cc68: e2822107 add r2, r2, #-1073741823 ; 0xc0000001 <== NOT EXECUTED
cc6c: e1510002 cmp r1, r2 <== NOT EXECUTED
case RTEMS_BLKIO_REQUEST:
/*
* It is not allowed to directly access the driver circumventing
* the cache.
*/
args->ioctl_return = (uint32_t) -1;
cc70: 03e03000 mvneq r3, #0 <== NOT EXECUTED
cc74: 0584300c streq r3, [r4, #12] <== NOT EXECUTED
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
int rc;
switch (args->command)
cc78: 0a000009 beq cca4 <rtems_blkdev_generic_ioctl+0x84> <== NOT EXECUTED
cc7c: e3a02911 mov r2, #278528 ; 0x44000 <== NOT EXECUTED
cc80: e2822f81 add r2, r2, #516 ; 0x204 <== NOT EXECUTED
cc84: e2822105 add r2, r2, #1073741825 ; 0x40000001 <== NOT EXECUTED
cc88: e1510002 cmp r1, r2 <== NOT EXECUTED
cc8c: 0a00001d beq cd08 <rtems_blkdev_generic_ioctl+0xe8> <== NOT EXECUTED
*/
args->ioctl_return = (uint32_t) -1;
break;
default:
args->ioctl_return = (uint32_t) dd->ioctl(dd->phys_dev,
cc90: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
cc94: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED
cc98: e1a0e00f mov lr, pc <== NOT EXECUTED
cc9c: e593f028 ldr pc, [r3, #40] ; 0x28 <== NOT EXECUTED
cca0: e584000c str r0, [r4, #12] <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
cca4: e3a00000 mov r0, #0 <== NOT EXECUTED
cca8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_libio_ioctl_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
int rc;
switch (args->command)
ccac: e3a02c42 mov r2, #16896 ; 0x4200 <== NOT EXECUTED
ccb0: e2822262 add r2, r2, #536870918 ; 0x20000006 <== NOT EXECUTED
ccb4: e1510002 cmp r1, r2 <== NOT EXECUTED
ccb8: 0a000019 beq cd24 <rtems_blkdev_generic_ioctl+0x104> <== NOT EXECUTED
ccbc: e3a02911 mov r2, #278528 ; 0x44000 <== NOT EXECUTED
ccc0: e2822c02 add r2, r2, #512 ; 0x200 <== NOT EXECUTED
ccc4: e2822109 add r2, r2, #1073741826 ; 0x40000002 <== NOT EXECUTED
ccc8: e1510002 cmp r1, r2 <== NOT EXECUTED
cccc: 1affffef bne cc90 <rtems_blkdev_generic_ioctl+0x70> <== NOT EXECUTED
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*((uint32_t *) args->buffer) = dd->media_block_size;
ccd0: e5932024 ldr r2, [r3, #36] ; 0x24 <== NOT EXECUTED
ccd4: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
ccd8: e5832000 str r2, [r3] <== NOT EXECUTED
args->ioctl_return = 0;
ccdc: e3a03000 mov r3, #0 <== NOT EXECUTED
cce0: e584300c str r3, [r4, #12] <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
cce4: e3a00000 mov r0, #0 <== NOT EXECUTED
cce8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
*((uint32_t *) args->buffer) = dd->block_size;
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *((uint32_t *) args->buffer);
ccec: e5942008 ldr r2, [r4, #8]
ccf0: e5922000 ldr r2, [r2]
ccf4: e5832020 str r2, [r3, #32]
args->ioctl_return = 0;
ccf8: e3a03000 mov r3, #0
ccfc: e584300c str r3, [r4, #12]
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
cd00: e3a00000 mov r0, #0
cd04: e8bd8010 pop {r4, pc}
dd->block_size = *((uint32_t *) args->buffer);
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETSIZE:
*((rtems_blkdev_bnum *) args->buffer) = dd->size;
cd08: e593201c ldr r2, [r3, #28] <== NOT EXECUTED
cd0c: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
cd10: e5832000 str r2, [r3] <== NOT EXECUTED
args->ioctl_return = 0;
cd14: e3a03000 mov r3, #0 <== NOT EXECUTED
cd18: e584300c str r3, [r4, #12] <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
cd1c: e3a00000 mov r0, #0 <== NOT EXECUTED
cd20: e8bd8010 pop {r4, pc} <== NOT EXECUTED
*((rtems_blkdev_bnum *) args->buffer) = dd->size;
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_SYNCDEV:
rc = rtems_bdbuf_syncdev(dd->dev);
cd24: e8930003 ldm r3, {r0, r1} <== NOT EXECUTED
cd28: ebfff791 bl ab74 <rtems_bdbuf_syncdev> <== NOT EXECUTED
args->ioctl_return = (uint32_t) (rc == RTEMS_SUCCESSFUL ? 0 : -1);
cd2c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
cd30: 13e03000 mvnne r3, #0 <== NOT EXECUTED
cd34: e584300c str r3, [r4, #12] <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
cd38: e3a00000 mov r0, #0 <== NOT EXECUTED
cd3c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
*((uint32_t *) args->buffer) = dd->media_block_size;
args->ioctl_return = 0;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*((uint32_t *) args->buffer) = dd->block_size;
cd40: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED
cd44: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
cd48: e5832000 str r2, [r3] <== NOT EXECUTED
args->ioctl_return = 0;
cd4c: e3a03000 mov r3, #0 <== NOT EXECUTED
cd50: e584300c str r3, [r4, #12] <== NOT EXECUTED
args->buffer);
break;
}
return RTEMS_SUCCESSFUL;
}
cd54: e3a00000 mov r0, #0 <== NOT EXECUTED
cd58: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0000ceac <rtems_blkdev_generic_read>:
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
ceac: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
ceb0: e5923000 ldr r3, [r2] <== NOT EXECUTED
ceb4: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
ceb8: e5924010 ldr r4, [r2, #16] <== NOT EXECUTED
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
cebc: e1a07002 mov r7, r2 <== NOT EXECUTED
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
cec0: e8930006 ldm r3, {r1, r2} <== NOT EXECUTED
rtems_device_driver
rtems_blkdev_generic_read(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
cec4: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
cec8: e3540000 cmp r4, #0 <== NOT EXECUTED
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
cecc: e3a05000 mov r5, #0 <== NOT EXECUTED
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
ced0: e5939020 ldr r9, [r3, #32] <== NOT EXECUTED
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
ced4: e88d0006 stm sp, {r1, r2} <== NOT EXECUTED
args->bytes_moved = 0;
ced8: e5875018 str r5, [r7, #24] <== NOT EXECUTED
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
cedc: e597600c ldr r6, [r7, #12] <== NOT EXECUTED
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
cee0: e9970c00 ldmib r7, {sl, fp} <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
blkofs = 0;
block++;
cee4: 01a03004 moveq r3, r4 <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
cee8: 0a000028 beq cf90 <rtems_blkdev_generic_read+0xe4> <== NOT EXECUTED
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
ceec: e1a03005 mov r3, r5 <== NOT EXECUTED
cef0: e1a0100b mov r1, fp <== NOT EXECUTED
cef4: e1a02009 mov r2, r9 <== NOT EXECUTED
cef8: e1a0000a mov r0, sl <== NOT EXECUTED
cefc: eb003ccb bl 1c230 <__divdi3> <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
cf00: e1a0100b mov r1, fp <== NOT EXECUTED
cf04: e1a03005 mov r3, r5 <== NOT EXECUTED
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
cf08: e1a08000 mov r8, r0 <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
cf0c: e1a02009 mov r2, r9 <== NOT EXECUTED
cf10: e1a0000a mov r0, sl <== NOT EXECUTED
cf14: eb003def bl 1c6d8 <__moddi3> <== NOT EXECUTED
cf18: e28db008 add fp, sp, #8 <== NOT EXECUTED
cf1c: e1a05000 mov r5, r0 <== NOT EXECUTED
cf20: ea000012 b cf70 <rtems_blkdev_generic_read+0xc4> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
cf24: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
cf28: e5931020 ldr r1, [r3, #32] <== NOT EXECUTED
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
cf2c: e15a0004 cmp sl, r4 <== NOT EXECUTED
cf30: 21a0a004 movcs sl, r4 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
cf34: e1a0200a mov r2, sl <== NOT EXECUTED
cf38: e0811005 add r1, r1, r5 <== NOT EXECUTED
cf3c: eb0016b8 bl 12a24 <memcpy> <== NOT EXECUTED
rc = rtems_bdbuf_release(diskbuf);
cf40: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
cf44: ebfff9b3 bl b618 <rtems_bdbuf_release> <== NOT EXECUTED
args->bytes_moved += copy;
cf48: e5972018 ldr r2, [r7, #24] <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
cf4c: e2503000 subs r3, r0, #0 <== NOT EXECUTED
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
cf50: e082200a add r2, r2, sl <== NOT EXECUTED
cf54: e5872018 str r2, [r7, #24] <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
cf58: 1a00000c bne cf90 <rtems_blkdev_generic_read+0xe4> <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
cf5c: e054400a subs r4, r4, sl <== NOT EXECUTED
cf60: 0a00000a beq cf90 <rtems_blkdev_generic_read+0xe4> <== NOT EXECUTED
rc = rtems_bdbuf_release(diskbuf);
args->bytes_moved += copy;
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
cf64: e086600a add r6, r6, sl <== NOT EXECUTED
blkofs = 0;
block++;
cf68: e2888001 add r8, r8, #1 <== NOT EXECUTED
cf6c: e1a05003 mov r5, r3 <== NOT EXECUTED
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
cf70: e1a0300b mov r3, fp <== NOT EXECUTED
cf74: e89d0003 ldm sp, {r0, r1} <== NOT EXECUTED
cf78: e1a02008 mov r2, r8 <== NOT EXECUTED
cf7c: ebfffe36 bl c85c <rtems_bdbuf_read> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
cf80: e2503000 subs r3, r0, #0 <== NOT EXECUTED
break;
copy = block_size - blkofs;
cf84: e065a009 rsb sl, r5, r9 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy(buf, (char *)diskbuf->buffer + blkofs, copy);
cf88: e1a00006 mov r0, r6 <== NOT EXECUTED
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
rc = rtems_bdbuf_read(dev, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
cf8c: 0affffe4 beq cf24 <rtems_blkdev_generic_read+0x78> <== NOT EXECUTED
blkofs = 0;
block++;
}
return rc;
}
cf90: e1a00003 mov r0, r3 <== NOT EXECUTED
cf94: e28dd00c add sp, sp, #12 <== NOT EXECUTED
cf98: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0000cd94 <rtems_blkdev_generic_write>:
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
cd94: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
cd98: e5923000 ldr r3, [r2] <== NOT EXECUTED
cd9c: e5933034 ldr r3, [r3, #52] ; 0x34 <== NOT EXECUTED
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
cda0: e5924010 ldr r4, [r2, #16] <== NOT EXECUTED
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
cda4: e1a07002 mov r7, r2 <== NOT EXECUTED
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
cda8: e8930006 ldm r3, {r1, r2} <== NOT EXECUTED
rtems_device_driver
rtems_blkdev_generic_write(
rtems_device_major_number major __attribute__((unused)),
rtems_device_minor_number minor __attribute__((unused)),
void * arg)
{
cdac: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
cdb0: e3540000 cmp r4, #0 <== NOT EXECUTED
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
cdb4: e3a05000 mov r5, #0 <== NOT EXECUTED
{
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
cdb8: e5939020 ldr r9, [r3, #32] <== NOT EXECUTED
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
cdbc: e88d0006 stm sp, {r1, r2} <== NOT EXECUTED
args->bytes_moved = 0;
cdc0: e5875018 str r5, [r7, #24] <== NOT EXECUTED
rtems_status_code rc = RTEMS_SUCCESSFUL;
rtems_libio_rw_args_t *args = arg;
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
cdc4: e597600c ldr r6, [r7, #12] <== NOT EXECUTED
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
cdc8: e9970c00 ldmib r7, {sl, fp} <== NOT EXECUTED
break;
count -= copy;
buf += copy;
blkofs = 0;
block++;
cdcc: 01a00004 moveq r0, r4 <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
cdd0: 0a000033 beq cea4 <rtems_blkdev_generic_write+0x110> <== NOT EXECUTED
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
cdd4: e1a03005 mov r3, r5 <== NOT EXECUTED
cdd8: e1a0100b mov r1, fp <== NOT EXECUTED
cddc: e1a02009 mov r2, r9 <== NOT EXECUTED
cde0: e1a0000a mov r0, sl <== NOT EXECUTED
cde4: eb003d11 bl 1c230 <__divdi3> <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
cde8: e1a0100b mov r1, fp <== NOT EXECUTED
cdec: e1a03005 mov r3, r5 <== NOT EXECUTED
rtems_libio_t *iop = args->iop;
rtems_disk_device *dd = iop->data1;
uint32_t block_size = dd->block_size;
char *buf = args->buffer;
uint32_t count = args->count;
rtems_blkdev_bnum block = (rtems_blkdev_bnum) (args->offset / block_size);
cdf0: e1a08000 mov r8, r0 <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
cdf4: e1a02009 mov r2, r9 <== NOT EXECUTED
cdf8: e1a0000a mov r0, sl <== NOT EXECUTED
cdfc: eb003e35 bl 1c6d8 <__moddi3> <== NOT EXECUTED
ce00: e28db008 add fp, sp, #8 <== NOT EXECUTED
ce04: e1a05000 mov r5, r0 <== NOT EXECUTED
ce08: ea00001a b ce78 <rtems_blkdev_generic_write+0xe4> <== NOT EXECUTED
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dev, block, &diskbuf);
ce0c: e89d0003 ldm sp, {r0, r1} <== NOT EXECUTED
ce10: e1a02008 mov r2, r8 <== NOT EXECUTED
ce14: e1a0300b mov r3, fp <== NOT EXECUTED
ce18: ebfffe5b bl c78c <rtems_bdbuf_get> <== NOT EXECUTED
else
rc = rtems_bdbuf_read(dev, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
ce1c: e3500000 cmp r0, #0 <== NOT EXECUTED
break;
copy = block_size - blkofs;
ce20: e065a009 rsb sl, r5, r9 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
ce24: e1a01006 mov r1, r6 <== NOT EXECUTED
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dev, block, &diskbuf);
else
rc = rtems_bdbuf_read(dev, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
ce28: 1a00001d bne cea4 <rtems_blkdev_generic_write+0x110> <== NOT EXECUTED
break;
copy = block_size - blkofs;
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
ce2c: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED
ce30: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED
else
rc = rtems_bdbuf_read(dev, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
copy = block_size - blkofs;
ce34: e15a0004 cmp sl, r4 <== NOT EXECUTED
ce38: 21a0a004 movcs sl, r4 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
ce3c: e1a0200a mov r2, sl <== NOT EXECUTED
ce40: e0800005 add r0, r0, r5 <== NOT EXECUTED
ce44: eb0016f6 bl 12a24 <memcpy> <== NOT EXECUTED
args->bytes_moved += copy;
ce48: e5973018 ldr r3, [r7, #24] <== NOT EXECUTED
ce4c: e083300a add r3, r3, sl <== NOT EXECUTED
ce50: e5873018 str r3, [r7, #24] <== NOT EXECUTED
rc = rtems_bdbuf_release_modified(diskbuf);
ce54: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED
ce58: ebfff9cc bl b590 <rtems_bdbuf_release_modified> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
ce5c: e3500000 cmp r0, #0 <== NOT EXECUTED
ce60: 1a00000f bne cea4 <rtems_blkdev_generic_write+0x110> <== NOT EXECUTED
uint32_t blkofs = (uint32_t) (args->offset % block_size);
dev_t dev = dd->dev;
args->bytes_moved = 0;
while (count > 0)
ce64: e054400a subs r4, r4, sl <== NOT EXECUTED
ce68: 0a00000d beq cea4 <rtems_blkdev_generic_write+0x110> <== NOT EXECUTED
rc = rtems_bdbuf_release_modified(diskbuf);
if (rc != RTEMS_SUCCESSFUL)
break;
count -= copy;
buf += copy;
ce6c: e086600a add r6, r6, sl <== NOT EXECUTED
blkofs = 0;
block++;
ce70: e2888001 add r8, r8, #1 <== NOT EXECUTED
ce74: e1a05000 mov r5, r0 <== NOT EXECUTED
while (count > 0)
{
rtems_bdbuf_buffer *diskbuf;
uint32_t copy;
if ((blkofs == 0) && (count >= block_size))
ce78: e1540009 cmp r4, r9 <== NOT EXECUTED
ce7c: 23550000 cmpcs r5, #0 <== NOT EXECUTED
ce80: 0affffe1 beq ce0c <rtems_blkdev_generic_write+0x78> <== NOT EXECUTED
rc = rtems_bdbuf_get(dev, block, &diskbuf);
else
rc = rtems_bdbuf_read(dev, block, &diskbuf);
ce84: e89d0003 ldm sp, {r0, r1} <== NOT EXECUTED
ce88: e1a0300b mov r3, fp <== NOT EXECUTED
ce8c: e1a02008 mov r2, r8 <== NOT EXECUTED
ce90: ebfffe71 bl c85c <rtems_bdbuf_read> <== NOT EXECUTED
if (rc != RTEMS_SUCCESSFUL)
ce94: e3500000 cmp r0, #0 <== NOT EXECUTED
break;
copy = block_size - blkofs;
ce98: e065a009 rsb sl, r5, r9 <== NOT EXECUTED
if (copy > count)
copy = count;
memcpy((char *)diskbuf->buffer + blkofs, buf, copy);
ce9c: e1a01006 mov r1, r6 <== NOT EXECUTED
if ((blkofs == 0) && (count >= block_size))
rc = rtems_bdbuf_get(dev, block, &diskbuf);
else
rc = rtems_bdbuf_read(dev, block, &diskbuf);
if (rc != RTEMS_SUCCESSFUL)
cea0: 0affffe1 beq ce2c <rtems_blkdev_generic_write+0x98> <== NOT EXECUTED
blkofs = 0;
block++;
}
return rc;
}
cea4: e28dd00c add sp, sp, #12 <== NOT EXECUTED
cea8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0000cb74 <rtems_blkdev_ioctl>:
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
size_t *arg_size = argp;
int rc = 0;
switch (req)
cb74: e3a03911 mov r3, #278528 ; 0x44000
cb78: e2833c02 add r3, r3, #512 ; 0x200
cb7c: e283310d add r3, r3, #1073741827 ; 0x40000003
cb80: e1510003 cmp r1, r3
return RTEMS_SUCCESSFUL;
}
int
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
cb84: e52de004 push {lr} ; (str lr, [sp, #-4]!)
size_t *arg_size = argp;
int rc = 0;
switch (req)
cb88: 0a00001c beq cc00 <rtems_blkdev_ioctl+0x8c>
cb8c: 9a00000d bls cbc8 <rtems_blkdev_ioctl+0x54>
cb90: e3a03911 mov r3, #278528 ; 0x44000 <== NOT EXECUTED
cb94: e2833f81 add r3, r3, #516 ; 0x204 <== NOT EXECUTED
cb98: e2833105 add r3, r3, #1073741825 ; 0x40000001 <== NOT EXECUTED
cb9c: e1510003 cmp r1, r3 <== NOT EXECUTED
cba0: 0a000012 beq cbf0 <rtems_blkdev_ioctl+0x7c> <== NOT EXECUTED
cba4: e3a03102 mov r3, #-2147483648 ; 0x80000000 <== NOT EXECUTED
cba8: e2833911 add r3, r3, #278528 ; 0x44000 <== NOT EXECUTED
cbac: e2833f81 add r3, r3, #516 ; 0x204 <== NOT EXECUTED
cbb0: e1510003 cmp r1, r3 <== NOT EXECUTED
cbb4: 1a000008 bne cbdc <rtems_blkdev_ioctl+0x68> <== NOT EXECUTED
case RTEMS_BLKIO_GETBLKSIZE:
*arg_size = dd->block_size;
break;
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *arg_size;
cbb8: e5923000 ldr r3, [r2] <== NOT EXECUTED
cbbc: e5803020 str r3, [r0, #32] <== NOT EXECUTED
cbc0: e3a00000 mov r0, #0 <== NOT EXECUTED
break;
cbc4: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
rtems_blkdev_ioctl(rtems_disk_device *dd, uint32_t req, void *argp)
{
size_t *arg_size = argp;
int rc = 0;
switch (req)
cbc8: e3a03911 mov r3, #278528 ; 0x44000
cbcc: e2833c02 add r3, r3, #512 ; 0x200
cbd0: e2833109 add r3, r3, #1073741826 ; 0x40000002
cbd4: e1510003 cmp r1, r3
cbd8: 0a00000c beq cc10 <rtems_blkdev_ioctl+0x9c>
case RTEMS_BLKIO_GETSIZE:
*arg_size = dd->size;
break;
default:
errno = EINVAL;
cbdc: eb001582 bl 121ec <__errno>
cbe0: e3a03016 mov r3, #22
cbe4: e5803000 str r3, [r0]
cbe8: e3e00000 mvn r0, #0
rc = -1;
break;
}
return rc;
}
cbec: e49df004 pop {pc} ; (ldr pc, [sp], #4)
case RTEMS_BLKIO_SETBLKSIZE:
dd->block_size = *arg_size;
break;
case RTEMS_BLKIO_GETSIZE:
*arg_size = dd->size;
cbf0: e590301c ldr r3, [r0, #28] <== NOT EXECUTED
cbf4: e3a00000 mov r0, #0 <== NOT EXECUTED
cbf8: e5823000 str r3, [r2] <== NOT EXECUTED
break;
cbfc: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*arg_size = dd->media_block_size;
break;
case RTEMS_BLKIO_GETBLKSIZE:
*arg_size = dd->block_size;
cc00: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED
cc04: e3a00000 mov r0, #0 <== NOT EXECUTED
cc08: e5823000 str r3, [r2] <== NOT EXECUTED
break;
cc0c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
int rc = 0;
switch (req)
{
case RTEMS_BLKIO_GETMEDIABLKSIZE:
*arg_size = dd->media_block_size;
cc10: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED
cc14: e3a00000 mov r0, #0 <== NOT EXECUTED
cc18: e5823000 str r3, [r2] <== NOT EXECUTED
break;
cc1c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0000e1e8 <rtems_deviceio_errno>:
{ 0, 0, 0 },
};
int
rtems_deviceio_errno(rtems_status_code code)
{
e1e8: e92d4010 push {r4, lr} <== NOT EXECUTED
e1ec: e1a01000 mov r1, r0 <== NOT EXECUTED
int rc;
if ((rc = rtems_assoc_remote_by_local(errno_assoc, (uint32_t ) code)))
e1f0: e59f0018 ldr r0, [pc, #24] ; e210 <rtems_deviceio_errno+0x28><== NOT EXECUTED
e1f4: eb000006 bl e214 <rtems_assoc_remote_by_local> <== NOT EXECUTED
e1f8: e2504000 subs r4, r0, #0 <== NOT EXECUTED
e1fc: 0a000001 beq e208 <rtems_deviceio_errno+0x20> <== NOT EXECUTED
{
errno = rc;
e200: eb00002e bl e2c0 <__errno> <== NOT EXECUTED
e204: e5804000 str r4, [r0] <== NOT EXECUTED
return -1;
}
return -1;
}
e208: e3e00000 mvn r0, #0 <== NOT EXECUTED
e20c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00002100 <rtems_disk_delete>:
}
}
rtems_status_code
rtems_disk_delete(dev_t dev)
{
2100: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
2104: e24dd010 sub sp, sp, #16
2108: e1a04000 mov r4, r0
210c: e1a05001 mov r5, r1
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
sc = disk_lock();
2110: ebffff89 bl 1f3c <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
2114: e3500000 cmp r0, #0
2118: e58d000c str r0, [sp, #12]
211c: 0a000002 beq 212c <rtems_disk_delete+0x2c>
rtems_disk_cleanup(dd);
disk_unlock();
return RTEMS_SUCCESSFUL;
}
2120: e59d000c ldr r0, [sp, #12]
2124: e28dd010 add sp, sp, #16
2128: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
sc = disk_lock();
if (sc != RTEMS_SUCCESSFUL) {
return sc;
}
dd = get_disk_entry(dev, true);
212c: e1a00004 mov r0, r4
2130: e1a01005 mov r1, r5
2134: e3a02001 mov r2, #1
2138: ebfffefd bl 1d34 <get_disk_entry>
if (dd == NULL) {
213c: e2503000 subs r3, r0, #0
2140: 0a000061 beq 22cc <rtems_disk_delete+0x1cc>
disk_unlock();
return RTEMS_INVALID_ID;
}
dd->deleted = true;
2144: e3a0a001 mov sl, #1
2148: e5c3a030 strb sl, [r3, #48] ; 0x30
}
static void
rtems_disk_cleanup(rtems_disk_device *disk_to_remove)
{
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
214c: e5936008 ldr r6, [r3, #8]
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
2150: e5d62030 ldrb r2, [r6, #48] ; 0x30
2154: e3520000 cmp r2, #0
2158: 0a00002c beq 2210 <rtems_disk_delete+0x110>
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
215c: e59f9178 ldr r9, [pc, #376] ; 22dc <rtems_disk_delete+0x1dc>
2160: e5993000 ldr r3, [r9]
2164: e3530000 cmp r3, #0
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
2168: e5962004 ldr r2, [r6, #4]
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
216c: 059d300c ldreq r3, [sp, #12]
rtems_disk_device *const physical_disk = disk_to_remove->phys_dev;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
2170: e5967000 ldr r7, [r6]
2174: e58d2008 str r2, [sp, #8]
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
2178: 058d3004 streq r3, [sp, #4]
217c: 0a000043 beq 2290 <rtems_disk_delete+0x190>
2180: e59d800c ldr r8, [sp, #12]
2184: e58d8004 str r8, [sp, #4]
rtems_disk_device_table *dtab = disktab + major;
2188: e5995004 ldr r5, [r9, #4]
218c: e0855188 add r5, r5, r8, lsl #3
for (minor = 0; minor < dtab->size; ++minor) {
2190: e595e004 ldr lr, [r5, #4]
2194: e35e0000 cmp lr, #0
2198: 0a000038 beq 2280 <rtems_disk_delete+0x180>
219c: e3a04000 mov r4, #0
21a0: e58d8000 str r8, [sp]
21a4: ea000008 b 21cc <rtems_disk_delete+0xcc>
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
21a8: e11c0001 tst ip, r1
21ac: 0a000003 beq 21c0 <rtems_disk_delete+0xc0>
if (dd->uses == 0) {
21b0: e5902014 ldr r2, [r0, #20]
21b4: e3520000 cmp r2, #0
++deleted_count;
dtab->minor [minor] = NULL;
free_disk_device(dd);
} else {
dd->deleted = true;
21b8: 15c0a030 strbne sl, [r0, #48] ; 0x30
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
if (dd->uses == 0) {
21bc: 0a000025 beq 2258 <rtems_disk_delete+0x158>
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
21c0: e2844001 add r4, r4, #1
21c4: e154000e cmp r4, lr
21c8: 2a00002b bcs 227c <rtems_disk_delete+0x17c>
rtems_disk_device *dd = dtab->minor [minor];
21cc: e5953000 ldr r3, [r5]
21d0: e7930104 ldr r0, [r3, r4, lsl #2]
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
21d4: e3500000 cmp r0, #0
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
21d8: e1a0b104 lsl fp, r4, #2
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
21dc: 0afffff7 beq 21c0 <rtems_disk_delete+0xc0>
21e0: e5902008 ldr r2, [r0, #8]
21e4: e5921000 ldr r1, [r2]
21e8: e056c000 subs ip, r6, r0
21ec: 13a0c001 movne ip, #1
21f0: e1510007 cmp r1, r7
21f4: e3a01000 mov r1, #0
21f8: 1affffea bne 21a8 <rtems_disk_delete+0xa8>
21fc: e5922004 ldr r2, [r2, #4]
2200: e59d8008 ldr r8, [sp, #8]
2204: e1520008 cmp r2, r8
2208: 03a01001 moveq r1, #1
220c: eaffffe5 b 21a8 <rtems_disk_delete+0xa8>
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
2210: e5932014 ldr r2, [r3, #20]
2214: e3520000 cmp r2, #0
2218: 0a000001 beq 2224 <rtems_disk_delete+0x124>
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
221c: ebffff52 bl 1f6c <disk_unlock>
return RTEMS_SUCCESSFUL;
2220: eaffffbe b 2120 <rtems_disk_delete+0x20>
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
2224: e59f20b0 ldr r2, [pc, #176] ; 22dc <rtems_disk_delete+0x1dc>
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
2228: e593c000 ldr ip, [r3]
disktab [major].minor [minor] = NULL;
222c: e5922004 ldr r2, [r2, #4]
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
2230: e5961014 ldr r1, [r6, #20]
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
2234: e792218c ldr r2, [r2, ip, lsl #3]
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
2238: e5933004 ldr r3, [r3, #4]
disktab [major].minor [minor] = NULL;
223c: e59d800c ldr r8, [sp, #12]
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
}
} else {
if (disk_to_remove->uses == 0) {
--physical_disk->uses;
2240: e2411001 sub r1, r1, #1
2244: e5861014 str r1, [r6, #20]
rtems_filesystem_split_dev_t(disk_to_remove->dev, major, minor);
disktab [major].minor [minor] = NULL;
2248: e7828103 str r8, [r2, r3, lsl #2]
free_disk_device(disk_to_remove);
224c: ebfffed6 bl 1dac <free_disk_device>
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
2250: ebffff45 bl 1f6c <disk_unlock>
2254: eaffffb1 b 2120 <rtems_disk_delete+0x20>
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
if (dd->uses == 0) {
++deleted_count;
dtab->minor [minor] = NULL;
2258: e783200b str r2, [r3, fp]
free_disk_device(dd);
225c: ebfffed2 bl 1dac <free_disk_device>
for (minor = 0; minor < dtab->size; ++minor) {
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
if (dd->uses == 0) {
++deleted_count;
2260: e59d1004 ldr r1, [sp, #4]
2264: e595e004 ldr lr, [r5, #4]
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
2268: e2844001 add r4, r4, #1
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
if (dd->uses == 0) {
++deleted_count;
226c: e2811001 add r1, r1, #1
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
2270: e154000e cmp r4, lr
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL && dd->phys_dev->dev == dev && dd != physical_disk) {
if (dd->uses == 0) {
++deleted_count;
2274: e58d1004 str r1, [sp, #4]
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
2278: 3affffd3 bcc 21cc <rtems_disk_delete+0xcc>
227c: e59d8000 ldr r8, [sp]
if (physical_disk->deleted) {
dev_t dev = physical_disk->dev;
unsigned deleted_count = 0;
for (major = 0; major < disktab_size; ++major) {
2280: e5993000 ldr r3, [r9]
2284: e2888001 add r8, r8, #1
2288: e1580003 cmp r8, r3
228c: 3affffbd bcc 2188 <rtems_disk_delete+0x88>
}
}
}
}
physical_disk->uses -= deleted_count;
2290: e5963014 ldr r3, [r6, #20]
2294: e59d2004 ldr r2, [sp, #4]
2298: e0623003 rsb r3, r2, r3
if (physical_disk->uses == 0) {
229c: e3530000 cmp r3, #0
}
}
}
}
physical_disk->uses -= deleted_count;
22a0: e5863014 str r3, [r6, #20]
if (physical_disk->uses == 0) {
22a4: 1affffdc bne 221c <rtems_disk_delete+0x11c>
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
22a8: e5961000 ldr r1, [r6]
disktab [major].minor [minor] = NULL;
22ac: e5992004 ldr r2, [r9, #4]
22b0: e7922181 ldr r2, [r2, r1, lsl #3]
}
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
22b4: e5961004 ldr r1, [r6, #4]
disktab [major].minor [minor] = NULL;
free_disk_device(physical_disk);
22b8: e1a00006 mov r0, r6
}
physical_disk->uses -= deleted_count;
if (physical_disk->uses == 0) {
rtems_filesystem_split_dev_t(physical_disk->dev, major, minor);
disktab [major].minor [minor] = NULL;
22bc: e7823101 str r3, [r2, r1, lsl #2]
free_disk_device(physical_disk);
22c0: ebfffeb9 bl 1dac <free_disk_device>
}
dd->deleted = true;
rtems_disk_cleanup(dd);
disk_unlock();
22c4: ebffff28 bl 1f6c <disk_unlock>
22c8: eaffff94 b 2120 <rtems_disk_delete+0x20>
return sc;
}
dd = get_disk_entry(dev, true);
if (dd == NULL) {
disk_unlock();
22cc: ebffff26 bl 1f6c <disk_unlock> <== NOT EXECUTED
22d0: e3a01004 mov r1, #4 <== NOT EXECUTED
22d4: e58d100c str r1, [sp, #12] <== NOT EXECUTED
return RTEMS_INVALID_ID;
22d8: eaffff90 b 2120 <rtems_disk_delete+0x20> <== NOT EXECUTED
00001dfc <rtems_disk_io_done>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_disk_io_done(void)
{
1dfc: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
1e00: e59f7088 ldr r7, [pc, #136] ; 1e90 <rtems_disk_io_done+0x94>
1e04: e5973000 ldr r3, [r7]
1e08: e3530000 cmp r3, #0
1e0c: 0a000016 beq 1e6c <rtems_disk_io_done+0x70>
1e10: e3a06000 mov r6, #0
rtems_disk_device_table *dtab = disktab + major;
1e14: e5972004 ldr r2, [r7, #4]
1e18: e0825186 add r5, r2, r6, lsl #3
for (minor = 0; minor < dtab->size; ++minor) {
1e1c: e5953004 ldr r3, [r5, #4]
1e20: e3530000 cmp r3, #0
1e24: 07922186 ldreq r2, [r2, r6, lsl #3]
1e28: 0a000009 beq 1e54 <rtems_disk_io_done+0x58>
1e2c: e7922186 ldr r2, [r2, r6, lsl #3]
1e30: e3a04000 mov r4, #0
rtems_disk_device *dd = dtab->minor [minor];
1e34: e7920104 ldr r0, [r2, r4, lsl #2]
if (dd != NULL) {
1e38: e3500000 cmp r0, #0
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
1e3c: e2844001 add r4, r4, #1
rtems_disk_device *dd = dtab->minor [minor];
if (dd != NULL) {
1e40: 0a000001 beq 1e4c <rtems_disk_io_done+0x50>
free_disk_device(dd);
1e44: ebffffd8 bl 1dac <free_disk_device> <== NOT EXECUTED
1e48: e895000c ldm r5, {r2, r3} <== NOT EXECUTED
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
rtems_disk_device_table *dtab = disktab + major;
for (minor = 0; minor < dtab->size; ++minor) {
1e4c: e1530004 cmp r3, r4
1e50: 8afffff7 bhi 1e34 <rtems_disk_io_done+0x38>
if (dd != NULL) {
free_disk_device(dd);
}
}
free(dtab->minor);
1e54: e1a00002 mov r0, r2
1e58: eb0004a8 bl 3100 <free>
rtems_disk_io_done(void)
{
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
for (major = 0; major < disktab_size; ++major) {
1e5c: e5973000 ldr r3, [r7]
1e60: e2866001 add r6, r6, #1
1e64: e1530006 cmp r3, r6
1e68: 8affffe9 bhi 1e14 <rtems_disk_io_done+0x18>
free_disk_device(dd);
}
}
free(dtab->minor);
}
free(disktab);
1e6c: e5970004 ldr r0, [r7, #4]
1e70: eb0004a2 bl 3100 <free>
rtems_semaphore_delete(diskdevs_mutex);
1e74: e5970008 ldr r0, [r7, #8]
1e78: eb0012fd bl 6a74 <rtems_semaphore_delete>
diskdevs_mutex = RTEMS_ID_NONE;
1e7c: e3a00000 mov r0, #0
disktab = NULL; disktab_size = 0;
1e80: e5870000 str r0, [r7]
}
free(disktab);
rtems_semaphore_delete(diskdevs_mutex);
diskdevs_mutex = RTEMS_ID_NONE;
1e84: e5870008 str r0, [r7, #8]
disktab = NULL;
1e88: e5870004 str r0, [r7, #4]
disktab_size = 0;
return RTEMS_SUCCESSFUL;
}
1e8c: e8bd80f0 pop {r4, r5, r6, r7, pc}
00001e94 <rtems_disk_io_initialize>:
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
1e94: e92d4030 push {r4, r5, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
1e98: e59f4094 ldr r4, [pc, #148] ; 1f34 <rtems_disk_io_initialize+0xa0>
1e9c: e5945000 ldr r5, [r4]
1ea0: e3550000 cmp r5, #0
}
}
rtems_status_code
rtems_disk_io_initialize(void)
{
1ea4: e24dd004 sub sp, sp, #4
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_device_major_number size = DISKTAB_INITIAL_SIZE;
if (disktab_size > 0) {
1ea8: 13a00000 movne r0, #0
1eac: 0a000001 beq 1eb8 <rtems_disk_io_initialize+0x24>
}
disktab_size = size;
return RTEMS_SUCCESSFUL;
}
1eb0: e28dd004 add sp, sp, #4
1eb4: e8bd8030 pop {r4, r5, pc}
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
1eb8: e3a00008 mov r0, #8
1ebc: e1a01000 mov r1, r0
1ec0: eb0003f8 bl 2ea8 <calloc>
if (disktab == NULL) {
1ec4: e3500000 cmp r0, #0
if (disktab_size > 0) {
return RTEMS_SUCCESSFUL;
}
disktab = calloc(size, sizeof(rtems_disk_device_table));
1ec8: e5840004 str r0, [r4, #4]
if (disktab == NULL) {
1ecc: 0a00000b beq 1f00 <rtems_disk_io_initialize+0x6c>
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
sc = rtems_semaphore_create(
1ed0: e284c008 add ip, r4, #8
1ed4: e1a03005 mov r3, r5
1ed8: e59f0058 ldr r0, [pc, #88] ; 1f38 <rtems_disk_io_initialize+0xa4>
1edc: e3a01001 mov r1, #1
1ee0: e3a02010 mov r2, #16
1ee4: e58dc000 str ip, [sp]
disktab = calloc(size, sizeof(rtems_disk_device_table));
if (disktab == NULL) {
return RTEMS_NO_MEMORY;
}
diskdevs_protected = false;
1ee8: e5c4500c strb r5, [r4, #12]
sc = rtems_semaphore_create(
1eec: eb00126e bl 68ac <rtems_semaphore_create>
RTEMS_FIFO | RTEMS_BINARY_SEMAPHORE | RTEMS_NO_INHERIT_PRIORITY
| RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL,
0,
&diskdevs_mutex
);
if (sc != RTEMS_SUCCESSFUL) {
1ef0: e3500000 cmp r0, #0
1ef4: 0a000003 beq 1f08 <rtems_disk_io_initialize+0x74>
free(disktab);
1ef8: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED
1efc: eb00047f bl 3100 <free> <== NOT EXECUTED
1f00: e3a0001a mov r0, #26 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
1f04: eaffffe9 b 1eb0 <rtems_disk_io_initialize+0x1c> <== NOT EXECUTED
}
sc = rtems_bdbuf_init();
1f08: eb00238d bl ad44 <rtems_bdbuf_init>
if (sc != RTEMS_SUCCESSFUL) {
1f0c: e3500000 cmp r0, #0
free(disktab);
return RTEMS_UNSATISFIED;
}
disktab_size = size;
1f10: 03a03008 moveq r3, #8
1f14: 05843000 streq r3, [r4]
return RTEMS_NO_MEMORY;
}
sc = rtems_bdbuf_init();
if (sc != RTEMS_SUCCESSFUL) {
1f18: 0affffe4 beq 1eb0 <rtems_disk_io_initialize+0x1c>
rtems_semaphore_delete(diskdevs_mutex);
1f1c: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
1f20: eb0012d3 bl 6a74 <rtems_semaphore_delete> <== NOT EXECUTED
free(disktab);
1f24: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED
1f28: eb000474 bl 3100 <free> <== NOT EXECUTED
1f2c: e3a0000d mov r0, #13 <== NOT EXECUTED
return RTEMS_UNSATISFIED;
1f30: eaffffde b 1eb0 <rtems_disk_io_initialize+0x1c> <== NOT EXECUTED
00001fa0 <rtems_disk_next>:
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (dev != (dev_t) -1) {
1fa0: e3700001 cmn r0, #1
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_next(dev_t dev)
{
1fa4: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (dev != (dev_t) -1) {
1fa8: 0a00002f beq 206c <rtems_disk_next+0xcc>
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
1fac: e2914001 adds r4, r1, #1
1fb0: 31a05000 movcc r5, r0
1fb4: 2a00001c bcs 202c <rtems_disk_next+0x8c>
} else {
++minor;
}
}
sc = disk_lock();
1fb8: ebffffdf bl 1f3c <disk_lock>
if (sc != RTEMS_SUCCESSFUL) {
1fbc: e2506000 subs r6, r0, #0
1fc0: 1a00001b bne 2034 <rtems_disk_next+0x94>
return NULL;
}
if (major >= disktab_size) {
1fc4: e59f30c0 ldr r3, [pc, #192] ; 208c <rtems_disk_next+0xec>
1fc8: e5930000 ldr r0, [r3]
1fcc: e1550000 cmp r5, r0
1fd0: 2a00002a bcs 2080 <rtems_disk_next+0xe0>
disk_unlock();
return NULL;
}
dtab = disktab + major;
1fd4: e5931004 ldr r1, [r3, #4]
1fd8: e7913185 ldr r3, [r1, r5, lsl #3]
1fdc: e0816185 add r6, r1, r5, lsl #3
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
1fe0: e3530000 cmp r3, #0
1fe4: 0a000009 beq 2010 <rtems_disk_next+0x70>
1fe8: e5962004 ldr r2, [r6, #4]
1fec: e1540002 cmp r4, r2
1ff0: 2a000006 bcs 2010 <rtems_disk_next+0x70>
disk_unlock();
return NULL;
}
dtab = disktab + major;
} else if (dtab->minor [minor] == NULL) {
1ff4: e7932104 ldr r2, [r3, r4, lsl #2]
1ff8: e3520000 cmp r2, #0
1ffc: e1a07104 lsl r7, r4, #2
2000: 1a000010 bne 2048 <rtems_disk_next+0xa8>
return NULL;
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
2004: e3530000 cmp r3, #0
return NULL;
}
dtab = disktab + major;
} else if (dtab->minor [minor] == NULL) {
++minor;
2008: e2844001 add r4, r4, #1
return NULL;
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
200c: 1afffff5 bne 1fe8 <rtems_disk_next+0x48>
minor = 0;
++major;
2010: e2855001 add r5, r5, #1
if (major >= disktab_size) {
2014: e1500005 cmp r0, r5
2018: 9a000007 bls 203c <rtems_disk_next+0x9c>
disk_unlock();
return NULL;
}
dtab = disktab + major;
201c: e0816185 add r6, r1, r5, lsl #3
2020: e7913185 ldr r3, [r1, r5, lsl #3]
2024: e3a04000 mov r4, #0
return NULL;
}
dtab = disktab + major;
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
2028: eaffffec b 1fe0 <rtems_disk_next+0x40>
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
/* If major wraps around */
if ((major + 1) < major) {
202c: e2905001 adds r5, r0, #1 <== NOT EXECUTED
2030: 3a00000b bcc 2064 <rtems_disk_next+0xc4> <== NOT EXECUTED
++minor;
} else {
++dtab->minor [minor]->uses;
disk_unlock();
return dtab->minor [minor];
2034: e3a00000 mov r0, #0 <== NOT EXECUTED
}
}
}
2038: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
while (true) {
if (dtab->minor == NULL || minor >= dtab->size) {
minor = 0;
++major;
if (major >= disktab_size) {
disk_unlock();
203c: ebffffca bl 1f6c <disk_unlock>
2040: e3a00000 mov r0, #0
return NULL;
2044: e8bd80f0 pop {r4, r5, r6, r7, pc}
}
dtab = disktab + major;
} else if (dtab->minor [minor] == NULL) {
++minor;
} else {
++dtab->minor [minor]->uses;
2048: e5923014 ldr r3, [r2, #20]
204c: e2833001 add r3, r3, #1
2050: e5823014 str r3, [r2, #20]
disk_unlock();
2054: ebffffc4 bl 1f6c <disk_unlock>
return dtab->minor [minor];
2058: e5963000 ldr r3, [r6]
205c: e7930007 ldr r0, [r3, r7]
2060: e8bd80f0 pop {r4, r5, r6, r7, pc}
rtems_filesystem_split_dev_t(dev, major, minor);
/* If minor wraps around */
if ((minor + 1) < minor) {
/* If major wraps around */
if ((major + 1) < major) {
2064: e3a04000 mov r4, #0 <== NOT EXECUTED
2068: eaffffd2 b 1fb8 <rtems_disk_next+0x18> <== NOT EXECUTED
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device_table *dtab = NULL;
rtems_device_major_number major = 0;
rtems_device_minor_number minor = 0;
if (dev != (dev_t) -1) {
206c: e3710001 cmn r1, #1
2070: 03a04000 moveq r4, #0
2074: 01a05004 moveq r5, r4
2078: 1affffcb bne 1fac <rtems_disk_next+0xc>
207c: eaffffcd b 1fb8 <rtems_disk_next+0x18>
if (sc != RTEMS_SUCCESSFUL) {
return NULL;
}
if (major >= disktab_size) {
disk_unlock();
2080: ebffffb9 bl 1f6c <disk_unlock> <== NOT EXECUTED
2084: e1a00006 mov r0, r6 <== NOT EXECUTED
return NULL;
2088: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00002090 <rtems_disk_obtain>:
return RTEMS_SUCCESSFUL;
}
rtems_disk_device *
rtems_disk_obtain(dev_t dev)
{
2090: e92d4070 push {r4, r5, r6, lr}
2094: e1a05000 mov r5, r0
2098: e24dd004 sub sp, sp, #4
209c: e1a06001 mov r6, r1
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
20a0: e10f4000 mrs r4, CPSR
20a4: e3843080 orr r3, r4, #128 ; 0x80
20a8: e129f003 msr CPSR_fc, r3
rtems_status_code sc = RTEMS_SUCCESSFUL;
rtems_disk_device *dd = NULL;
rtems_interrupt_level level;
rtems_interrupt_disable(level);
if (!diskdevs_protected) {
20ac: e59f3048 ldr r3, [pc, #72] ; 20fc <rtems_disk_obtain+0x6c>
20b0: e5d3200c ldrb r2, [r3, #12]
20b4: e21220ff ands r2, r2, #255 ; 0xff
20b8: 1a000003 bne 20cc <rtems_disk_obtain+0x3c>
/* Frequent and quickest case */
dd = get_disk_entry(dev, false);
20bc: ebffff1c bl 1d34 <get_disk_entry>
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
20c0: e129f004 msr CPSR_fc, r4
disk_unlock();
}
}
return dd;
}
20c4: e28dd004 add sp, sp, #4
20c8: e8bd8070 pop {r4, r5, r6, pc}
20cc: e129f004 msr CPSR_fc, r4 <== NOT EXECUTED
dd = get_disk_entry(dev, false);
rtems_interrupt_enable(level);
} else {
rtems_interrupt_enable(level);
sc = disk_lock();
20d0: ebffff99 bl 1f3c <disk_lock> <== NOT EXECUTED
if (sc == RTEMS_SUCCESSFUL) {
20d4: e2502000 subs r2, r0, #0 <== NOT EXECUTED
20d8: 13a00000 movne r0, #0 <== NOT EXECUTED
20dc: 1afffff8 bne 20c4 <rtems_disk_obtain+0x34> <== NOT EXECUTED
dd = get_disk_entry(dev, false);
20e0: e1a01006 mov r1, r6 <== NOT EXECUTED
20e4: e1a00005 mov r0, r5 <== NOT EXECUTED
20e8: ebffff11 bl 1d34 <get_disk_entry> <== NOT EXECUTED
disk_unlock();
20ec: e58d0000 str r0, [sp] <== NOT EXECUTED
20f0: ebffff9d bl 1f6c <disk_unlock> <== NOT EXECUTED
20f4: e59d0000 ldr r0, [sp] <== NOT EXECUTED
20f8: eafffff1 b 20c4 <rtems_disk_obtain+0x34> <== NOT EXECUTED
000200c4 <rtems_dosfs_initialize>:
int rtems_dosfs_initialize(rtems_filesystem_mount_table_entry_t *mt_entry,
const void *data)
{
int rc;
rc = msdos_initialize_support(mt_entry,
200c4: e59f1008 ldr r1, [pc, #8] ; 200d4 <rtems_dosfs_initialize+0x10><== NOT EXECUTED 200c8: e59f2008 ldr r2, [pc, #8] ; 200d8 <rtems_dosfs_initialize+0x14><== NOT EXECUTED 200cc: e59f3008 ldr r3, [pc, #8] ; 200dc <rtems_dosfs_initialize+0x18><== NOT EXECUTED 200d0: ea000002 b 200e0 <msdos_initialize_support> <== NOT EXECUTED
00006d40 <rtems_error>:
int rtems_error(
rtems_error_code_t error_flag,
const char *printf_format,
...
)
{
6d40: e92d000e push {r1, r2, r3} <== NOT EXECUTED
6d44: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
6d48: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
6d4c: e28d300c add r3, sp, #12 <== NOT EXECUTED
chars_written = rtems_verror(error_flag, printf_format, arglist);
6d50: e1a02003 mov r2, r3 <== NOT EXECUTED
6d54: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED
)
{
va_list arglist;
int chars_written;
va_start(arglist, printf_format);
6d58: e58d3000 str r3, [sp] <== NOT EXECUTED
chars_written = rtems_verror(error_flag, printf_format, arglist);
6d5c: ebffff81 bl 6b68 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
return chars_written;
}
6d60: e28dd004 add sp, sp, #4 <== NOT EXECUTED
6d64: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
6d68: e28dd00c add sp, sp, #12 <== NOT EXECUTED
6d6c: e12fff1e bx lr <== NOT EXECUTED
00002020 <rtems_filesystem_evaluate_path>:
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
2020: e92d40f0 push {r4, r5, r6, r7, lr}
int i = 0;
2024: e3a0c000 mov ip, #0
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
2028: e24dd008 sub sp, sp, #8
/*
* Verify Input parameters.
*/
if ( !pathname )
202c: e2505000 subs r5, r0, #0
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
int i = 0;
2030: e58dc004 str ip, [sp, #4]
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
2034: e1a06001 mov r6, r1
2038: e1a04002 mov r4, r2
203c: e1a07003 mov r7, r3
/*
* Verify Input parameters.
*/
if ( !pathname )
2040: 0a000013 beq 2094 <rtems_filesystem_evaluate_path+0x74>
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !pathloc )
2044: e3530000 cmp r3, #0
2048: 0a00000c beq 2080 <rtems_filesystem_evaluate_path+0x60>
/*
* Evaluate the path using the optable evalpath.
*/
rtems_filesystem_get_start_loc( pathname, &i, pathloc );
204c: e1a02003 mov r2, r3
2050: e28d1004 add r1, sp, #4
2054: eb0003d5 bl 2fb0 <rtems_filesystem_get_start_loc>
/*
* We evaluation the path relative to the start location we get got.
*/
return rtems_filesystem_evaluate_relative_path( &pathname[i],
2058: e59d0004 ldr r0, [sp, #4]
205c: e59dc01c ldr ip, [sp, #28]
2060: e0601006 rsb r1, r0, r6
2064: e1a02004 mov r2, r4
2068: e0850000 add r0, r5, r0
206c: e1a03007 mov r3, r7
2070: e58dc000 str ip, [sp]
2074: ebffffad bl 1f30 <rtems_filesystem_evaluate_relative_path>
pathnamelen - i,
flags,
pathloc,
follow_link );
}
2078: e28dd008 add sp, sp, #8
207c: e8bd80f0 pop {r4, r5, r6, r7, pc}
if ( !pathname )
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !pathloc )
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
2080: eb00308e bl e2c0 <__errno> <== NOT EXECUTED
2084: e3a03005 mov r3, #5 <== NOT EXECUTED
2088: e5803000 str r3, [r0] <== NOT EXECUTED
208c: e3e00000 mvn r0, #0 <== NOT EXECUTED
2090: eafffff8 b 2078 <rtems_filesystem_evaluate_path+0x58> <== NOT EXECUTED
/*
* Verify Input parameters.
*/
if ( !pathname )
rtems_set_errno_and_return_minus_one( EFAULT );
2094: eb003089 bl e2c0 <__errno> <== NOT EXECUTED
2098: e3a0300e mov r3, #14 <== NOT EXECUTED
209c: e5803000 str r3, [r0] <== NOT EXECUTED
20a0: e3e00000 mvn r0, #0 <== NOT EXECUTED
20a4: eafffff3 b 2078 <rtems_filesystem_evaluate_path+0x58> <== NOT EXECUTED
00001f30 <rtems_filesystem_evaluate_relative_path>:
/*
* Verify Input parameters.
*/
if ( !pathname )
1f30: e3500000 cmp r0, #0
size_t pathnamelen,
int flags,
rtems_filesystem_location_info_t *pathloc,
int follow_link
)
{
1f34: e92d4030 push {r4, r5, lr}
1f38: e1a05002 mov r5, r2
1f3c: e1a04003 mov r4, r3
/*
* Verify Input parameters.
*/
if ( !pathname )
1f40: 0a00002c beq 1ff8 <rtems_filesystem_evaluate_relative_path+0xc8>
rtems_set_errno_and_return_minus_one( EFAULT );
if ( !pathloc )
1f44: e3530000 cmp r3, #0
1f48: 0a00002f beq 200c <rtems_filesystem_evaluate_relative_path+0xdc>
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
if ( !pathloc->ops->evalpath_h )
1f4c: e593c00c ldr ip, [r3, #12]
1f50: e59cc000 ldr ip, [ip]
1f54: e35c0000 cmp ip, #0
1f58: 0a000021 beq 1fe4 <rtems_filesystem_evaluate_relative_path+0xb4>
rtems_set_errno_and_return_minus_one( ENOTSUP );
result = (*pathloc->ops->evalpath_h)( pathname, pathnamelen, flags, pathloc );
1f5c: e1a0e00f mov lr, pc
1f60: e12fff1c bx ip
/*
* Get the Node type and determine if you need to follow the link or
* not.
*/
if ( (result == 0) && follow_link ) {
1f64: e59d200c ldr r2, [sp, #12]
1f68: e2703001 rsbs r3, r0, #1
1f6c: 33a03000 movcc r3, #0
1f70: e3520000 cmp r2, #0
1f74: 03a03000 moveq r3, #0
1f78: e3530000 cmp r3, #0
1f7c: 08bd8030 popeq {r4, r5, pc}
if ( !pathloc->ops->node_type_h ){
1f80: e594200c ldr r2, [r4, #12]
1f84: e5923010 ldr r3, [r2, #16]
1f88: e3530000 cmp r3, #0
1f8c: 0a00000f beq 1fd0 <rtems_filesystem_evaluate_relative_path+0xa0>
rtems_filesystem_freenode( pathloc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
type = (*pathloc->ops->node_type_h)( pathloc );
1f90: e1a00004 mov r0, r4
1f94: e1a0e00f mov lr, pc
1f98: e12fff13 bx r3
if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||
1f9c: e2400003 sub r0, r0, #3
1fa0: e3500001 cmp r0, #1
1fa4: 83a00000 movhi r0, #0
1fa8: 88bd8030 pophi {r4, r5, pc}
( type == RTEMS_FILESYSTEM_SYM_LINK ) ) {
if ( !pathloc->ops->eval_link_h ){
1fac: e594200c ldr r2, [r4, #12]
1fb0: e5923034 ldr r3, [r2, #52] ; 0x34
1fb4: e3530000 cmp r3, #0
1fb8: 0a000004 beq 1fd0 <rtems_filesystem_evaluate_relative_path+0xa0>
* pathloc will be passed up (and eventually released).
* Hence, the (valid) originial node that we submit to
* eval_link_h() should be released by the handler.
*/
result = (*pathloc->ops->eval_link_h)( pathloc, flags );
1fbc: e1a00004 mov r0, r4
1fc0: e1a01005 mov r1, r5
1fc4: e1a0e00f mov lr, pc
1fc8: e12fff13 bx r3
}
}
return result;
}
1fcc: e8bd8030 pop {r4, r5, pc}
if ( ( type == RTEMS_FILESYSTEM_HARD_LINK ) ||
( type == RTEMS_FILESYSTEM_SYM_LINK ) ) {
if ( !pathloc->ops->eval_link_h ){
rtems_filesystem_freenode( pathloc );
1fd0: e592301c ldr r3, [r2, #28] <== NOT EXECUTED
1fd4: e3530000 cmp r3, #0 <== NOT EXECUTED
1fd8: 11a00004 movne r0, r4 <== NOT EXECUTED
1fdc: 11a0e00f movne lr, pc <== NOT EXECUTED
1fe0: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
1fe4: eb0030b5 bl e2c0 <__errno> <== NOT EXECUTED
1fe8: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
1fec: e5803000 str r3, [r0] <== NOT EXECUTED
1ff0: e3e00000 mvn r0, #0 <== NOT EXECUTED
1ff4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
/*
* Verify Input parameters.
*/
if ( !pathname )
rtems_set_errno_and_return_minus_one( EFAULT );
1ff8: eb0030b0 bl e2c0 <__errno> <== NOT EXECUTED
1ffc: e3a0300e mov r3, #14 <== NOT EXECUTED
2000: e5803000 str r3, [r0] <== NOT EXECUTED
2004: e3e00000 mvn r0, #0 <== NOT EXECUTED
2008: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
if ( !pathloc )
rtems_set_errno_and_return_minus_one( EIO ); /* should never happen */
200c: eb0030ab bl e2c0 <__errno> <== NOT EXECUTED
2010: e3a03005 mov r3, #5 <== NOT EXECUTED
2014: e5803000 str r3, [r0] <== NOT EXECUTED
2018: e3e00000 mvn r0, #0 <== NOT EXECUTED
201c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00001d28 <rtems_filesystem_initialize>:
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
1d28: e92d40f0 push {r4, r5, r6, r7, lr}
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
1d2c: e59f2108 ldr r2, [pc, #264] ; 1e3c <rtems_filesystem_initialize+0x114>
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
1d30: e59f6108 ldr r6, [pc, #264] ; 1e40 <rtems_filesystem_initialize+0x118>
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
1d34: e5922000 ldr r2, [r2]
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
1d38: e5963000 ldr r3, [r6]
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
1d3c: e3520000 cmp r2, #0
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
1d40: e3a02012 mov r2, #18
* configuration is a single instantiation of the IMFS or miniIMFS with
* a single "/dev" directory in it.
*/
void rtems_filesystem_initialize( void )
{
1d44: e24dd018 sub sp, sp, #24
/*
* Set the default umask to "022".
*/
rtems_filesystem_umask = 022;
1d48: e583202c str r2, [r3, #44] ; 0x2c
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
1d4c: 0a00002e beq 1e0c <rtems_filesystem_initialize+0xe4>
rtems_fatal_error_occurred( 0xABCD0001 );
mt = &rtems_filesystem_mount_table[0];
1d50: e59f30ec ldr r3, [pc, #236] ; 1e44 <rtems_filesystem_initialize+0x11c>
1d54: e5932000 ldr r2, [r3]
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
1d58: e3a05000 mov r5, #0
1d5c: e5923004 ldr r3, [r2, #4]
1d60: e2820008 add r0, r2, #8
1d64: e8900003 ldm r0, {r0, r1}
1d68: e5922000 ldr r2, [r2]
1d6c: e58d5000 str r5, [sp]
1d70: eb000254 bl 26c8 <mount>
if ( status == -1 )
1d74: e3700001 cmn r0, #1
1d78: 0a00002b beq 1e2c <rtems_filesystem_initialize+0x104>
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
1d7c: e5963000 ldr r3, [r6]
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
1d80: e28d4004 add r4, sp, #4
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
rtems_filesystem_link_counts = 0;
1d84: e1c353b0 strh r5, [r3, #48] ; 0x30
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
1d88: e3a01001 mov r1, #1
1d8c: e1a03004 mov r3, r4
1d90: e1a02005 mov r2, r5
1d94: e59f00ac ldr r0, [pc, #172] ; 1e48 <rtems_filesystem_initialize+0x120>
rtems_filesystem_root = loc;
1d98: e1a07004 mov r7, r4
* gonna hit performance.
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
1d9c: e58d5000 str r5, [sp]
1da0: eb00009e bl 2020 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
1da4: e596c000 ldr ip, [r6]
1da8: e8b7000f ldm r7!, {r0, r1, r2, r3}
1dac: e28cc018 add ip, ip, #24
1db0: e8ac000f stmia ip!, {r0, r1, r2, r3}
1db4: e5973000 ldr r3, [r7]
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
1db8: e1a02005 mov r2, r5
*
* Till Straumann, 10/25/2002
*/
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
1dbc: e58c3000 str r3, [ip]
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
1dc0: e3a01001 mov r1, #1
1dc4: e1a03004 mov r3, r4
1dc8: e59f0078 ldr r0, [pc, #120] ; 1e48 <rtems_filesystem_initialize+0x120>
1dcc: e58d5000 str r5, [sp]
1dd0: eb000092 bl 2020 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
1dd4: e596c000 ldr ip, [r6]
1dd8: e8b4000f ldm r4!, {r0, r1, r2, r3}
1ddc: e28cc004 add ip, ip, #4
1de0: e8ac000f stmia ip!, {r0, r1, r2, r3}
1de4: e5973000 ldr r3, [r7]
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
1de8: e3a01f7f mov r1, #508 ; 0x1fc
/* Clone the root pathloc */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
/* One more clone for the current node */
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_current = loc;
1dec: e58c3000 str r3, [ip]
*
* NOTE: UNIX root is 755 and owned by root/root (0/0). It is actually
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
1df0: e2811003 add r1, r1, #3
1df4: e59f0050 ldr r0, [pc, #80] ; 1e4c <rtems_filesystem_initialize+0x124>
1df8: eb0001c2 bl 2508 <mkdir>
if ( status != 0 )
1dfc: e3500000 cmp r0, #0
1e00: 1a000005 bne 1e1c <rtems_filesystem_initialize+0xf4>
* it will be mounted onto is created. Moreover, if it is going to
* use a device, then it is REALLY unfair to attempt this
* before device drivers are initialized. So we return via a base
* filesystem image and nothing auto-mounted at this point.
*/
}
1e04: e28dd018 add sp, sp, #24
1e08: e8bd80f0 pop {r4, r5, r6, r7, pc}
/*
* mount the first filesystem.
*/
if ( rtems_filesystem_mount_table_size == 0 )
rtems_fatal_error_occurred( 0xABCD0001 );
1e0c: e3a004ab mov r0, #-1426063360 ; 0xab000000 <== NOT EXECUTED
1e10: e28008cd add r0, r0, #13434880 ; 0xcd0000 <== NOT EXECUTED
1e14: e2800001 add r0, r0, #1 <== NOT EXECUTED
1e18: eb000ff0 bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
* created that way by the IMFS.
*/
status = mkdir( "/dev", 0777);
if ( status != 0 )
rtems_fatal_error_occurred( 0xABCD0003 );
1e1c: e3a004ab mov r0, #-1426063360 ; 0xab000000 <== NOT EXECUTED
1e20: e28008cd add r0, r0, #13434880 ; 0xcd0000 <== NOT EXECUTED
1e24: e2800003 add r0, r0, #3 <== NOT EXECUTED
1e28: eb000fec bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
mt = &rtems_filesystem_mount_table[0];
status = mount( mt->device, mt->mount_point, mt->type, mt->fsoptions, NULL );
if ( status == -1 )
rtems_fatal_error_occurred( 0xABCD0002 );
1e2c: e3a004ab mov r0, #-1426063360 ; 0xab000000 <== NOT EXECUTED
1e30: e28008cd add r0, r0, #13434880 ; 0xcd0000 <== NOT EXECUTED
1e34: e2800002 add r0, r0, #2 <== NOT EXECUTED
1e38: eb000fe8 bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
0000b0e4 <rtems_filesystem_iterate>:
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
b0e4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
b0e8: e59f60ac ldr r6, [pc, #172] ; b19c <rtems_filesystem_iterate+0xb8>
b0ec: e5963000 ldr r3, [r6]
b0f0: e3530000 cmp r3, #0
bool rtems_filesystem_iterate(
rtems_per_filesystem_routine routine,
void *routine_arg
)
{
b0f4: e1a04000 mov r4, r0
b0f8: e1a05001 mov r5, r1
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
b0fc: 1a000003 bne b110 <rtems_filesystem_iterate+0x2c>
b100: ea00000c b b138 <rtems_filesystem_iterate+0x54> <== NOT EXECUTED
b104: e3500000 cmp r0, #0
b108: e2866008 add r6, r6, #8
b10c: 1a000020 bne b194 <rtems_filesystem_iterate+0xb0>
stop = (*routine)( table_entry, routine_arg );
b110: e1a00006 mov r0, r6
b114: e1a01005 mov r1, r5
b118: e1a0e00f mov lr, pc
b11c: e12fff14 bx r4
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
b120: e5963008 ldr r3, [r6, #8]
b124: e3530000 cmp r3, #0
stop = (*routine)( table_entry, routine_arg );
b128: e1a0a000 mov sl, r0
{
const rtems_filesystem_table_t *table_entry = &rtems_filesystem_table [0];
rtems_chain_node *node = NULL;
bool stop = false;
while ( table_entry->type && !stop ) {
b12c: 1afffff4 bne b104 <rtems_filesystem_iterate+0x20>
stop = (*routine)( table_entry, routine_arg );
++table_entry;
}
if ( !stop ) {
b130: e3500000 cmp r0, #0
b134: 1a000016 bne b194 <rtems_filesystem_iterate+0xb0>
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
b138: e59f7060 ldr r7, [pc, #96] ; b1a0 <rtems_filesystem_iterate+0xbc>
b13c: e3a01000 mov r1, #0
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return the_chain->first;
b140: e59f605c ldr r6, [pc, #92] ; b1a4 <rtems_filesystem_iterate+0xc0>
b144: e5970000 ldr r0, [r7]
b148: e1a02001 mov r2, r1
b14c: ebffe996 bl 57ac <rtems_semaphore_obtain>
b150: e4968004 ldr r8, [r6], #4
rtems_libio_lock();
for (
b154: e1580006 cmp r8, r6
b158: 03a0a000 moveq sl, #0
b15c: 1a000002 bne b16c <rtems_filesystem_iterate+0x88>
b160: ea000009 b b18c <rtems_filesystem_iterate+0xa8>
b164: e3500000 cmp r0, #0
b168: 1a000007 bne b18c <rtems_filesystem_iterate+0xa8>
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
b16c: e2880008 add r0, r8, #8
b170: e1a01005 mov r1, r5
b174: e1a0e00f mov lr, pc
b178: e12fff14 bx r4
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
b17c: e5988000 ldr r8, [r8]
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
b180: e1580006 cmp r8, r6
!rtems_chain_is_tail( &filesystem_chain, node ) && !stop;
node = rtems_chain_next( node )
) {
const filesystem_node *fsn = (filesystem_node *) node;
stop = (*routine)( &fsn->entry, routine_arg );
b184: e1a0a000 mov sl, r0
++table_entry;
}
if ( !stop ) {
rtems_libio_lock();
for (
b188: 1afffff5 bne b164 <rtems_filesystem_iterate+0x80>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
b18c: e5970000 ldr r0, [r7]
b190: ebffe9cd bl 58cc <rtems_semaphore_release>
}
rtems_libio_unlock();
}
return stop;
}
b194: e1a0000a mov r0, sl
b198: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
00002650 <rtems_filesystem_mount_iterate>:
bool rtems_filesystem_mount_iterate(
rtems_per_filesystem_mount_routine routine,
void *routine_arg
)
{
2650: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
2654: e59f7064 ldr r7, [pc, #100] ; 26c0 <rtems_filesystem_mount_iterate+0x70>
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return the_chain->first;
2658: e59f4064 ldr r4, [pc, #100] ; 26c4 <rtems_filesystem_mount_iterate+0x74>
265c: e1a06001 mov r6, r1
2660: e3a01000 mov r1, #0
2664: e1a05000 mov r5, r0
2668: e1a02001 mov r2, r1
266c: e5970000 ldr r0, [r7]
2670: eb000c4d bl 57ac <rtems_semaphore_obtain>
2674: e4948004 ldr r8, [r4], #4
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
2678: e1580004 cmp r8, r4
267c: 03a0a000 moveq sl, #0
2680: 1a000002 bne 2690 <rtems_filesystem_mount_iterate+0x40>
2684: ea000009 b 26b0 <rtems_filesystem_mount_iterate+0x60> <== NOT EXECUTED
2688: e3500000 cmp r0, #0
268c: 1a000007 bne 26b0 <rtems_filesystem_mount_iterate+0x60>
node = rtems_chain_next( node )
) {
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
2690: e1a00008 mov r0, r8
2694: e1a01006 mov r1, r6
2698: e1a0e00f mov lr, pc
269c: e12fff15 bx r5
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
26a0: e5988000 ldr r8, [r8]
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
26a4: e1580004 cmp r8, r4
node = rtems_chain_next( node )
) {
const rtems_filesystem_mount_table_entry_t *mt_entry =
(rtems_filesystem_mount_table_entry_t *) node;
stop = (*routine)( mt_entry, routine_arg );
26a8: e1a0a000 mov sl, r0
{
rtems_chain_node *node = NULL;
bool stop = false;
rtems_libio_lock();
for (
26ac: 1afffff5 bne 2688 <rtems_filesystem_mount_iterate+0x38>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
26b0: e5970000 ldr r0, [r7]
26b4: eb000c84 bl 58cc <rtems_semaphore_release>
stop = (*routine)( mt_entry, routine_arg );
}
rtems_libio_unlock();
return stop;
}
26b8: e1a0000a mov r0, sl
26bc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
00001e98 <rtems_filesystem_prefix_separators>:
int rtems_filesystem_prefix_separators(
const char *pathname,
int pathnamelen
)
{
1e98: e92d4070 push {r4, r5, r6, lr}
1e9c: e1a04000 mov r4, r0
/* * Eat any separators at start of the path. */ int stripped = 0; while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
1ea0: e5d00000 ldrb r0, [r0]
1ea4: e3510000 cmp r1, #0
1ea8: 13500000 cmpne r0, #0
1eac: 03a05000 moveq r5, #0
1eb0: 13a05001 movne r5, #1
1eb4: e1a06001 mov r6, r1
1eb8: 13a05000 movne r5, #0
1ebc: 1a000005 bne 1ed8 <rtems_filesystem_prefix_separators+0x40>
1ec0: ea000007 b 1ee4 <rtems_filesystem_prefix_separators+0x4c> <== NOT EXECUTED
{
pathname++;
pathnamelen--;
stripped++;
1ec4: e2855001 add r5, r5, #1
{
/*
* Eat any separators at start of the path.
*/
int stripped = 0;
while ( *pathname && pathnamelen && rtems_filesystem_is_separator( *pathname ) )
1ec8: e7d40005 ldrb r0, [r4, r5]
1ecc: e1560005 cmp r6, r5
1ed0: 13500000 cmpne r0, #0
1ed4: 0a000002 beq 1ee4 <rtems_filesystem_prefix_separators+0x4c>
1ed8: eb00044f bl 301c <rtems_filesystem_is_separator>
1edc: e3500000 cmp r0, #0
1ee0: 1afffff7 bne 1ec4 <rtems_filesystem_prefix_separators+0x2c>
pathname++;
pathnamelen--;
stripped++;
}
return stripped;
}
1ee4: e1a00005 mov r0, r5
1ee8: e8bd8070 pop {r4, r5, r6, pc}
0000b1dc <rtems_filesystem_register>:
int
rtems_filesystem_register(
const char *type,
rtems_filesystem_fsmount_me_t mount_h
)
{
b1dc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
b1e0: e1a08001 mov r8, r1
b1e4: e1a05000 mov r5, r0
size_t fsn_size = sizeof( filesystem_node ) + strlen(type) + 1;
b1e8: eb001039 bl f2d4 <strlen>
filesystem_node *fsn = malloc( fsn_size );
b1ec: e2800011 add r0, r0, #17
b1f0: ebffdc85 bl 240c <malloc>
char *type_storage = (char *) fsn + sizeof( filesystem_node );
if ( fsn == NULL )
b1f4: e2504000 subs r4, r0, #0
b1f8: 0a00001e beq b278 <rtems_filesystem_register+0x9c>
rtems_filesystem_fsmount_me_t mount_h
)
{
size_t fsn_size = sizeof( filesystem_node ) + strlen(type) + 1;
filesystem_node *fsn = malloc( fsn_size );
char *type_storage = (char *) fsn + sizeof( filesystem_node );
b1fc: e2847010 add r7, r4, #16
if ( fsn == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
strcpy(type_storage, type);
b200: e1a01005 mov r1, r5
b204: e1a00007 mov r0, r7
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
b208: e59f607c ldr r6, [pc, #124] ; b28c <rtems_filesystem_register+0xb0>
b20c: eb000fe0 bl f194 <strcpy>
b210: e3a01000 mov r1, #0
b214: e1a02001 mov r2, r1
fsn->entry.type = type_storage;
b218: e5847008 str r7, [r4, #8]
fsn->entry.mount_h = mount_h;
b21c: e584800c str r8, [r4, #12]
b220: e5960000 ldr r0, [r6]
b224: ebffe960 bl 57ac <rtems_semaphore_obtain>
rtems_libio_lock();
if ( rtems_filesystem_get_mount_handler( type ) == NULL ) {
b228: e1a00005 mov r0, r5
b22c: ebffffdd bl b1a8 <rtems_filesystem_get_mount_handler>
b230: e2505000 subs r5, r0, #0
b234: 1a000006 bne b254 <rtems_filesystem_register+0x78>
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
b238: e1a01004 mov r1, r4
b23c: e59f004c ldr r0, [pc, #76] ; b290 <rtems_filesystem_register+0xb4>
b240: ebffeb9d bl 60bc <_Chain_Append>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
b244: e5960000 ldr r0, [r6]
b248: ebffe99f bl 58cc <rtems_semaphore_release>
b24c: e1a00005 mov r0, r5
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_unlock();
return 0;
b250: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
b254: e5960000 ldr r0, [r6] <== NOT EXECUTED
b258: ebffe99b bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
rtems_libio_lock();
if ( rtems_filesystem_get_mount_handler( type ) == NULL ) {
rtems_chain_append( &filesystem_chain, &fsn->node );
} else {
rtems_libio_unlock();
free( fsn );
b25c: e1a00004 mov r0, r4 <== NOT EXECUTED
b260: ebffdb90 bl 20a8 <free> <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
b264: eb000c15 bl e2c0 <__errno> <== NOT EXECUTED
b268: e3a03016 mov r3, #22 <== NOT EXECUTED
b26c: e5803000 str r3, [r0] <== NOT EXECUTED
b270: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
rtems_libio_unlock();
return 0;
}
b274: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
size_t fsn_size = sizeof( filesystem_node ) + strlen(type) + 1;
filesystem_node *fsn = malloc( fsn_size );
char *type_storage = (char *) fsn + sizeof( filesystem_node );
if ( fsn == NULL )
rtems_set_errno_and_return_minus_one( ENOMEM );
b278: eb000c10 bl e2c0 <__errno> <== NOT EXECUTED
b27c: e3a0300c mov r3, #12 <== NOT EXECUTED
b280: e5803000 str r3, [r0] <== NOT EXECUTED
b284: e3e00000 mvn r0, #0 <== NOT EXECUTED
b288: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
0000b038 <rtems_filesystem_unregister>:
int
rtems_filesystem_unregister(
const char *type
)
{
b038: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
rtems_chain_node *node = NULL;
if ( type == NULL ) {
b03c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
b040: 0a000020 beq b0c8 <rtems_filesystem_unregister+0x90> <== NOT EXECUTED
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
b044: e59f6090 ldr r6, [pc, #144] ; b0dc <rtems_filesystem_unregister+0xa4><== NOT EXECUTED
b048: e3a01000 mov r1, #0 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return the_chain->first;
b04c: e59f408c ldr r4, [pc, #140] ; b0e0 <rtems_filesystem_unregister+0xa8><== NOT EXECUTED
b050: e5960000 ldr r0, [r6] <== NOT EXECUTED
b054: e1a02001 mov r2, r1 <== NOT EXECUTED
b058: ebffe9d3 bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
b05c: e4947004 ldr r7, [r4], #4 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EINVAL );
}
rtems_libio_lock();
for (
b060: e1570004 cmp r7, r4 <== NOT EXECUTED
b064: 1a000003 bne b078 <rtems_filesystem_unregister+0x40> <== NOT EXECUTED
b068: ea00000f b b0ac <rtems_filesystem_unregister+0x74> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
b06c: e5977000 ldr r7, [r7] <== NOT EXECUTED
b070: e1570004 cmp r7, r4 <== NOT EXECUTED
b074: 0a00000c beq b0ac <rtems_filesystem_unregister+0x74> <== NOT EXECUTED
!rtems_chain_is_tail( &filesystem_chain, node );
node = rtems_chain_next( node )
) {
filesystem_node *fsn = (filesystem_node *) node;
if ( strcmp( fsn->entry.type, type ) == 0 ) {
b078: e5970008 ldr r0, [r7, #8] <== NOT EXECUTED
b07c: e1a01005 mov r1, r5 <== NOT EXECUTED
b080: eb000fb7 bl ef64 <strcmp> <== NOT EXECUTED
b084: e2508000 subs r8, r0, #0 <== NOT EXECUTED
b088: 1afffff7 bne b06c <rtems_filesystem_unregister+0x34> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
b08c: e1a00007 mov r0, r7 <== NOT EXECUTED
b090: ebffec14 bl 60e8 <_Chain_Extract> <== NOT EXECUTED
rtems_chain_extract( node );
free( fsn );
b094: e1a00007 mov r0, r7 <== NOT EXECUTED
b098: ebffdc02 bl 20a8 <free> <== NOT EXECUTED
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
b09c: e5960000 ldr r0, [r6] <== NOT EXECUTED
b0a0: ebffea09 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
b0a4: e1a00008 mov r0, r8 <== NOT EXECUTED
rtems_libio_unlock();
return 0;
b0a8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
b0ac: e5960000 ldr r0, [r6] <== NOT EXECUTED
b0b0: ebffea05 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
}
}
rtems_libio_unlock();
rtems_set_errno_and_return_minus_one( ENOENT );
b0b4: eb000c81 bl e2c0 <__errno> <== NOT EXECUTED
b0b8: e3a03002 mov r3, #2 <== NOT EXECUTED
b0bc: e5803000 str r3, [r0] <== NOT EXECUTED
b0c0: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
b0c4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
)
{
rtems_chain_node *node = NULL;
if ( type == NULL ) {
rtems_set_errno_and_return_minus_one( EINVAL );
b0c8: eb000c7c bl e2c0 <__errno> <== NOT EXECUTED
b0cc: e3a03016 mov r3, #22 <== NOT EXECUTED
b0d0: e5803000 str r3, [r0] <== NOT EXECUTED
b0d4: e3e00000 mvn r0, #0 <== NOT EXECUTED
b0d8: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00006de8 <rtems_fsmount>:
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
6de8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
bool terminate = false;
/*
* scan through all fstab entries;
*/
while (!terminate &&
6dec: e2517000 subs r7, r1, #0 <== NOT EXECUTED
6df0: 01a06007 moveq r6, r7 <== NOT EXECUTED
)
/*-------------------------------------------------------------------------*\
| Return Value: |
| 0, if success, -1 and errno if failed |
\*=========================================================================*/
{
6df4: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
6df8: e1a0a002 mov sl, r2 <== NOT EXECUTED
bool terminate = false;
/*
* scan through all fstab entries;
*/
while (!terminate &&
6dfc: 01a05006 moveq r5, r6 <== NOT EXECUTED
6e00: 0a00000e beq 6e40 <rtems_fsmount+0x58> <== NOT EXECUTED
rc = tmp_rc;
}
}
else {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {
fprintf(stdout,"fsmount: mounting of \"%s\" to"
6e04: e59f8138 ldr r8, [pc, #312] ; 6f44 <rtems_fsmount+0x15c> <== NOT EXECUTED
bool terminate = false;
/*
* scan through all fstab entries;
*/
while (!terminate &&
6e08: e2804014 add r4, r0, #20 <== NOT EXECUTED
6e0c: e3a06000 mov r6, #0 <== NOT EXECUTED
tmp_rc = 0;
/*
* create mount point
*/
if (tmp_rc == 0) {
tmp_rc = rtems_mkdir(fstab_ptr->target, S_IRWXU | S_IRWXG | S_IRWXO);
6e10: e3a01f7f mov r1, #508 ; 0x1fc <== NOT EXECUTED
6e14: e2811003 add r1, r1, #3 <== NOT EXECUTED
6e18: e5140010 ldr r0, [r4, #-16] <== NOT EXECUTED
6e1c: eb00099b bl 9490 <rtems_mkdir> <== NOT EXECUTED
if (tmp_rc != 0) {
6e20: e2505000 subs r5, r0, #0 <== NOT EXECUTED
6e24: 0a00000a beq 6e54 <rtems_fsmount+0x6c> <== NOT EXECUTED
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNTPNT_CRTERR)) {
6e28: e15430b4 ldrh r3, [r4, #-4] <== NOT EXECUTED
6e2c: e3130002 tst r3, #2 <== NOT EXECUTED
6e30: 1a000019 bne 6e9c <rtems_fsmount+0xb4> <== NOT EXECUTED
fprintf(stdout,"fsmount: creation of mount point \"%s\" failed: %s\n",
fstab_ptr->target,
strerror(errno));
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNTPNT_CRTERR)) {
6e34: e15430b2 ldrh r3, [r4, #-2] <== NOT EXECUTED
6e38: e3130002 tst r3, #2 <== NOT EXECUTED
6e3c: 0a000010 beq 6e84 <rtems_fsmount+0x9c> <== NOT EXECUTED
if (!terminate) {
fstab_ptr++;
fstab_idx++;
}
}
if (fail_idx != NULL) {
6e40: e35a0000 cmp sl, #0 <== NOT EXECUTED
*fail_idx = fstab_idx;
6e44: 158a6000 strne r6, [sl] <== NOT EXECUTED
} return rc; }
6e48: e1a00005 mov r0, r5 <== NOT EXECUTED
6e4c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
6e50: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
}
/*
* mount device to given mount point
*/
if (tmp_rc == 0) {
tmp_rc = mount(fstab_ptr->source,
6e54: e2440014 sub r0, r4, #20 <== NOT EXECUTED
6e58: e890000f ldm r0, {r0, r1, r2, r3} <== NOT EXECUTED
6e5c: e58d5000 str r5, [sp] <== NOT EXECUTED
6e60: eb000677 bl 8844 <mount> <== NOT EXECUTED
fstab_ptr->target,
fstab_ptr->type,
fstab_ptr->options,
NULL);
if (tmp_rc != 0) {
6e64: e2505000 subs r5, r0, #0 <== NOT EXECUTED
6e68: 0a000017 beq 6ecc <rtems_fsmount+0xe4> <== NOT EXECUTED
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_FAILED)) {
6e6c: e15430b4 ldrh r3, [r4, #-4] <== NOT EXECUTED
6e70: e3130004 tst r3, #4 <== NOT EXECUTED
6e74: 1a00001c bne 6eec <rtems_fsmount+0x104> <== NOT EXECUTED
" \"%s\" failed: %s\n",
fstab_ptr->source,
fstab_ptr->target,
strerror(errno));
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNT_FAILED)) {
6e78: e15430b2 ldrh r3, [r4, #-2] <== NOT EXECUTED
6e7c: e3130004 tst r3, #4 <== NOT EXECUTED
6e80: 1affffee bne 6e40 <rtems_fsmount+0x58> <== NOT EXECUTED
/*
* proceed to next entry
*/
if (!terminate) {
fstab_ptr++;
fstab_idx++;
6e84: e2866001 add r6, r6, #1 <== NOT EXECUTED
bool terminate = false;
/*
* scan through all fstab entries;
*/
while (!terminate &&
6e88: e1570006 cmp r7, r6 <== NOT EXECUTED
/*
* proceed to next entry
*/
if (!terminate) {
fstab_ptr++;
fstab_idx++;
6e8c: e2844014 add r4, r4, #20 <== NOT EXECUTED
bool terminate = false;
/*
* scan through all fstab entries;
*/
while (!terminate &&
6e90: 8affffde bhi 6e10 <rtems_fsmount+0x28> <== NOT EXECUTED
6e94: e3a05000 mov r5, #0 <== NOT EXECUTED
6e98: eaffffe8 b 6e40 <rtems_fsmount+0x58> <== NOT EXECUTED
*/
if (tmp_rc == 0) {
tmp_rc = rtems_mkdir(fstab_ptr->target, S_IRWXU | S_IRWXG | S_IRWXO);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNTPNT_CRTERR)) {
fprintf(stdout,"fsmount: creation of mount point \"%s\" failed: %s\n",
6e9c: e5983000 ldr r3, [r8] <== NOT EXECUTED
6ea0: e5149010 ldr r9, [r4, #-16] <== NOT EXECUTED
6ea4: e593b008 ldr fp, [r3, #8] <== NOT EXECUTED
6ea8: eb00f050 bl 42ff0 <__errno> <== NOT EXECUTED
6eac: e5900000 ldr r0, [r0] <== NOT EXECUTED
6eb0: eb0109bf bl 495b4 <strerror> <== NOT EXECUTED
6eb4: e1a02009 mov r2, r9 <== NOT EXECUTED
6eb8: e1a03000 mov r3, r0 <== NOT EXECUTED
6ebc: e59f1084 ldr r1, [pc, #132] ; 6f48 <rtems_fsmount+0x160> <== NOT EXECUTED
6ec0: e1a0000b mov r0, fp <== NOT EXECUTED
6ec4: eb00f2c0 bl 439cc <fprintf> <== NOT EXECUTED
6ec8: eaffffd9 b 6e34 <rtems_fsmount+0x4c> <== NOT EXECUTED
terminate = true;
rc = tmp_rc;
}
}
else {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {
6ecc: e15430b4 ldrh r3, [r4, #-4] <== NOT EXECUTED
6ed0: e3130001 tst r3, #1 <== NOT EXECUTED
6ed4: 1a000013 bne 6f28 <rtems_fsmount+0x140> <== NOT EXECUTED
fprintf(stdout,"fsmount: mounting of \"%s\" to"
" \"%s\" succeeded\n",
fstab_ptr->source,
fstab_ptr->target);
}
if (0 != (fstab_ptr->abort_reasons & FSMOUNT_MNT_OK)) {
6ed8: e15430b2 ldrh r3, [r4, #-2] <== NOT EXECUTED
6edc: e3130001 tst r3, #1 <== NOT EXECUTED
6ee0: 0affffe7 beq 6e84 <rtems_fsmount+0x9c> <== NOT EXECUTED
bool terminate = false;
/*
* scan through all fstab entries;
*/
while (!terminate &&
6ee4: e3a05000 mov r5, #0 <== NOT EXECUTED
6ee8: eaffffd4 b 6e40 <rtems_fsmount+0x58> <== NOT EXECUTED
fstab_ptr->type,
fstab_ptr->options,
NULL);
if (tmp_rc != 0) {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_FAILED)) {
fprintf(stdout,"fsmount: mounting of \"%s\" to"
6eec: e5983000 ldr r3, [r8] <== NOT EXECUTED
6ef0: e5142014 ldr r2, [r4, #-20] <== NOT EXECUTED
6ef4: e593b008 ldr fp, [r3, #8] <== NOT EXECUTED
6ef8: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
6efc: e5149010 ldr r9, [r4, #-16] <== NOT EXECUTED
6f00: eb00f03a bl 42ff0 <__errno> <== NOT EXECUTED
6f04: e5900000 ldr r0, [r0] <== NOT EXECUTED
6f08: eb0109a9 bl 495b4 <strerror> <== NOT EXECUTED
6f0c: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED
6f10: e58d0000 str r0, [sp] <== NOT EXECUTED
6f14: e1a03009 mov r3, r9 <== NOT EXECUTED
6f18: e1a0000b mov r0, fp <== NOT EXECUTED
6f1c: e59f1028 ldr r1, [pc, #40] ; 6f4c <rtems_fsmount+0x164> <== NOT EXECUTED
6f20: eb00f2a9 bl 439cc <fprintf> <== NOT EXECUTED
6f24: eaffffd3 b 6e78 <rtems_fsmount+0x90> <== NOT EXECUTED
rc = tmp_rc;
}
}
else {
if (0 != (fstab_ptr->report_reasons & FSMOUNT_MNT_OK)) {
fprintf(stdout,"fsmount: mounting of \"%s\" to"
6f28: e5983000 ldr r3, [r8] <== NOT EXECUTED
6f2c: e59f101c ldr r1, [pc, #28] ; 6f50 <rtems_fsmount+0x168> <== NOT EXECUTED
6f30: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
6f34: e2442014 sub r2, r4, #20 <== NOT EXECUTED
6f38: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
6f3c: eb00f2a2 bl 439cc <fprintf> <== NOT EXECUTED
6f40: eaffffe4 b 6ed8 <rtems_fsmount+0xf0> <== NOT EXECUTED
00001bdc <rtems_io_lookup_name>:
rtems_status_code rtems_io_lookup_name(
const char *name,
rtems_driver_name_t *device_info
)
{
1bdc: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
1be0: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
1be4: e1a06001 mov r6, r1 <== NOT EXECUTED
1be8: e1a05000 mov r5, r0 <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path( name, strlen( name ), 0x00, &loc, true );
1bec: eb0035b8 bl f2d4 <strlen> <== NOT EXECUTED
1bf0: e28d4004 add r4, sp, #4 <== NOT EXECUTED
1bf4: e1a01000 mov r1, r0 <== NOT EXECUTED
1bf8: e3a02000 mov r2, #0 <== NOT EXECUTED
1bfc: e1a03004 mov r3, r4 <== NOT EXECUTED
1c00: e3a0c001 mov ip, #1 <== NOT EXECUTED
1c04: e1a00005 mov r0, r5 <== NOT EXECUTED
1c08: e58dc000 str ip, [sp] <== NOT EXECUTED
1c0c: eb000103 bl 2020 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
the_jnode = loc.node_access;
if ( !loc.ops->node_type_h ) {
1c10: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED
1c14: e5923010 ldr r3, [r2, #16] <== NOT EXECUTED
1c18: e3530000 cmp r3, #0 <== NOT EXECUTED
IMFS_jnode_t *the_jnode;
rtems_filesystem_location_info_t loc;
int result;
rtems_filesystem_node_types_t node_type;
result = rtems_filesystem_evaluate_path( name, strlen( name ), 0x00, &loc, true );
1c1c: e1a07000 mov r7, r0 <== NOT EXECUTED
the_jnode = loc.node_access;
1c20: e59d8004 ldr r8, [sp, #4] <== NOT EXECUTED
if ( !loc.ops->node_type_h ) {
1c24: 0a000013 beq 1c78 <rtems_io_lookup_name+0x9c> <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
node_type = (*loc.ops->node_type_h)( &loc );
1c28: e1a00004 mov r0, r4 <== NOT EXECUTED
1c2c: e1a0e00f mov lr, pc <== NOT EXECUTED
1c30: e12fff13 bx r3 <== NOT EXECUTED
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
1c34: e3570000 cmp r7, #0 <== NOT EXECUTED
1c38: 03500002 cmpeq r0, #2 <== NOT EXECUTED
1c3c: 03a07000 moveq r7, #0 <== NOT EXECUTED
1c40: 13a07001 movne r7, #1 <== NOT EXECUTED
1c44: 0a000015 beq 1ca0 <rtems_io_lookup_name+0xc4> <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
1c48: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
1c4c: e3530000 cmp r3, #0 <== NOT EXECUTED
1c50: 0a000025 beq 1cec <rtems_io_lookup_name+0x110> <== NOT EXECUTED
1c54: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
1c58: e3530000 cmp r3, #0 <== NOT EXECUTED
1c5c: 0a000022 beq 1cec <rtems_io_lookup_name+0x110> <== NOT EXECUTED
1c60: e1a00004 mov r0, r4 <== NOT EXECUTED
1c64: e1a0e00f mov lr, pc <== NOT EXECUTED
1c68: e12fff13 bx r3 <== NOT EXECUTED
1c6c: e3a0000d mov r0, #13 <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
return RTEMS_SUCCESSFUL;
}
1c70: e28dd018 add sp, sp, #24 <== NOT EXECUTED
1c74: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
result = rtems_filesystem_evaluate_path( name, strlen( name ), 0x00, &loc, true );
the_jnode = loc.node_access;
if ( !loc.ops->node_type_h ) {
rtems_filesystem_freenode( &loc );
1c78: e592301c ldr r3, [r2, #28] <== NOT EXECUTED
1c7c: e3530000 cmp r3, #0 <== NOT EXECUTED
1c80: 11a00004 movne r0, r4 <== NOT EXECUTED
1c84: 11a0e00f movne lr, pc <== NOT EXECUTED
1c88: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
1c8c: eb00318b bl e2c0 <__errno> <== NOT EXECUTED
1c90: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
1c94: e5803000 str r3, [r0] <== NOT EXECUTED
1c98: e3e00000 mvn r0, #0 <== NOT EXECUTED
1c9c: eafffff3 b 1c70 <rtems_io_lookup_name+0x94> <== NOT EXECUTED
if ( (result != 0) || node_type != RTEMS_FILESYSTEM_DEVICE ) {
rtems_filesystem_freenode( &loc );
return RTEMS_UNSATISFIED;
}
device_info->device_name = (char *) name;
1ca0: e5865000 str r5, [r6] <== NOT EXECUTED
device_info->device_name_length = strlen( name );
1ca4: e1a00005 mov r0, r5 <== NOT EXECUTED
1ca8: eb003589 bl f2d4 <strlen> <== NOT EXECUTED
1cac: e5860004 str r0, [r6, #4] <== NOT EXECUTED
device_info->major = the_jnode->info.device.major;
1cb0: e5983050 ldr r3, [r8, #80] ; 0x50 <== NOT EXECUTED
1cb4: e5863008 str r3, [r6, #8] <== NOT EXECUTED
device_info->minor = the_jnode->info.device.minor;
rtems_filesystem_freenode( &loc );
1cb8: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
}
device_info->device_name = (char *) name;
device_info->device_name_length = strlen( name );
device_info->major = the_jnode->info.device.major;
device_info->minor = the_jnode->info.device.minor;
1cbc: e5982054 ldr r2, [r8, #84] ; 0x54 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
1cc0: e3530000 cmp r3, #0 <== NOT EXECUTED
}
device_info->device_name = (char *) name;
device_info->device_name_length = strlen( name );
device_info->major = the_jnode->info.device.major;
device_info->minor = the_jnode->info.device.minor;
1cc4: e586200c str r2, [r6, #12] <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
1cc8: 0a000009 beq 1cf4 <rtems_io_lookup_name+0x118> <== NOT EXECUTED
1ccc: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
1cd0: e3530000 cmp r3, #0 <== NOT EXECUTED
1cd4: 0a000006 beq 1cf4 <rtems_io_lookup_name+0x118> <== NOT EXECUTED
1cd8: e1a00004 mov r0, r4 <== NOT EXECUTED
1cdc: e1a0e00f mov lr, pc <== NOT EXECUTED
1ce0: e12fff13 bx r3 <== NOT EXECUTED
1ce4: e1a00007 mov r0, r7 <== NOT EXECUTED
1ce8: eaffffe0 b 1c70 <rtems_io_lookup_name+0x94> <== NOT EXECUTED
1cec: e3a0000d mov r0, #13 <== NOT EXECUTED
1cf0: eaffffde b 1c70 <rtems_io_lookup_name+0x94> <== NOT EXECUTED
1cf4: e3a00000 mov r0, #0 <== NOT EXECUTED
1cf8: eaffffdc b 1c70 <rtems_io_lookup_name+0x94> <== NOT EXECUTED
000071f0 <rtems_io_register_driver>:
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
if ( rtems_interrupt_is_in_progress() )
71f0: e59f3148 ldr r3, [pc, #328] ; 7340 <rtems_io_register_driver+0x150>
71f4: e593c000 ldr ip, [r3]
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
rtems_device_major_number major_limit = _IO_Number_of_drivers;
71f8: e59f3144 ldr r3, [pc, #324] ; 7344 <rtems_io_register_driver+0x154>
if ( rtems_interrupt_is_in_progress() )
71fc: e35c0000 cmp ip, #0
rtems_status_code rtems_io_register_driver(
rtems_device_major_number major,
const rtems_driver_address_table *driver_table,
rtems_device_major_number *registered_major
)
{
7200: e92d4010 push {r4, lr}
7204: e1a04000 mov r4, r0
rtems_device_major_number major_limit = _IO_Number_of_drivers;
7208: e5930000 ldr r0, [r3]
if ( rtems_interrupt_is_in_progress() )
720c: 13a00012 movne r0, #18
7210: 18bd8010 popne {r4, pc}
return RTEMS_CALLED_FROM_ISR;
if ( registered_major == NULL )
7214: e3520000 cmp r2, #0
7218: 0a00003d beq 7314 <rtems_io_register_driver+0x124>
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
if ( driver_table == NULL )
721c: e3510000 cmp r1, #0
if ( registered_major == NULL )
return RTEMS_INVALID_ADDRESS;
/* Set it to an invalid value */
*registered_major = major_limit;
7220: e5820000 str r0, [r2]
if ( driver_table == NULL )
7224: 0a00003a beq 7314 <rtems_io_register_driver+0x124>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
7228: e591c000 ldr ip, [r1]
722c: e35c0000 cmp ip, #0
7230: 0a000034 beq 7308 <rtems_io_register_driver+0x118>
return RTEMS_INVALID_ADDRESS;
if ( rtems_io_is_empty_table( driver_table ) )
return RTEMS_INVALID_ADDRESS;
if ( major >= major_limit )
7234: e1500004 cmp r0, r4
7238: 93a0000a movls r0, #10
723c: 98bd8010 popls {r4, pc}
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
7240: e59f0100 ldr r0, [pc, #256] ; 7348 <rtems_io_register_driver+0x158>
7244: e590c000 ldr ip, [r0]
7248: e28cc001 add ip, ip, #1
724c: e580c000 str ip, [r0]
return RTEMS_INVALID_NUMBER;
_Thread_Disable_dispatch();
if ( major == 0 ) {
7250: e3540000 cmp r4, #0
7254: 1a000020 bne 72dc <rtems_io_register_driver+0xec>
static rtems_status_code rtems_io_obtain_major_number(
rtems_device_major_number *major
)
{
rtems_device_major_number n = _IO_Number_of_drivers;
7258: e593e000 ldr lr, [r3]
rtems_device_major_number m = 0;
/* major is error checked by caller */
for ( m = 0; m < n; ++m ) {
725c: e35e0000 cmp lr, #0
7260: 0a00002d beq 731c <rtems_io_register_driver+0x12c>
7264: e59f30e0 ldr r3, [pc, #224] ; 734c <rtems_io_register_driver+0x15c>
7268: e593c000 ldr ip, [r3]
726c: e1a0300c mov r3, ip
7270: ea000003 b 7284 <rtems_io_register_driver+0x94>
7274: e2844001 add r4, r4, #1
7278: e15e0004 cmp lr, r4
727c: e2833018 add r3, r3, #24
7280: 9a000005 bls 729c <rtems_io_register_driver+0xac>
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
7284: e5930000 ldr r0, [r3]
7288: e3500000 cmp r0, #0
728c: 1afffff8 bne 7274 <rtems_io_register_driver+0x84>
7290: e5930004 ldr r0, [r3, #4]
7294: e3500000 cmp r0, #0
7298: 1afffff5 bne 7274 <rtems_io_register_driver+0x84>
}
/* Assigns invalid value in case of failure */
*major = m;
if ( m != n )
729c: e15e0004 cmp lr, r4
72a0: 10843084 addne r3, r4, r4, lsl #1
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
72a4: e5824000 str r4, [r2]
if ( m != n )
72a8: 108cc183 addne ip, ip, r3, lsl #3
72ac: 0a00001b beq 7320 <rtems_io_register_driver+0x130>
}
*registered_major = major;
}
_IO_Driver_address_table [major] = *driver_table;
72b0: e1a0e001 mov lr, r1
72b4: e8be000f ldm lr!, {r0, r1, r2, r3}
72b8: e8ac000f stmia ip!, {r0, r1, r2, r3}
72bc: e89e0003 ldm lr, {r0, r1}
72c0: e88c0003 stm ip, {r0, r1}
_Thread_Enable_dispatch();
72c4: eb000680 bl 8ccc <_Thread_Enable_dispatch>
return rtems_io_initialize( major, 0, NULL );
72c8: e3a01000 mov r1, #0
72cc: e1a00004 mov r0, r4
72d0: e1a02001 mov r2, r1
}
72d4: e8bd4010 pop {r4, lr}
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
72d8: ea0021bb b f9cc <rtems_io_initialize>
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
72dc: e59f3068 ldr r3, [pc, #104] ; 734c <rtems_io_register_driver+0x15c>
72e0: e084c084 add ip, r4, r4, lsl #1
72e4: e5933000 ldr r3, [r3]
72e8: e1a0c18c lsl ip, ip, #3
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
72ec: e793000c ldr r0, [r3, ip]
72f0: e3500000 cmp r0, #0
_Thread_Enable_dispatch();
return sc;
}
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
72f4: e083c00c add ip, r3, ip
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
72f8: 0a00000b beq 732c <rtems_io_register_driver+0x13c>
major = *registered_major;
} else {
rtems_driver_address_table *const table = _IO_Driver_address_table + major;
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
72fc: eb000672 bl 8ccc <_Thread_Enable_dispatch>
7300: e3a0000c mov r0, #12
return RTEMS_RESOURCE_IN_USE;
7304: e8bd8010 pop {r4, pc}
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
7308: e591c004 ldr ip, [r1, #4]
730c: e35c0000 cmp ip, #0
7310: 1affffc7 bne 7234 <rtems_io_register_driver+0x44>
_IO_Driver_address_table [major] = *driver_table;
_Thread_Enable_dispatch();
return rtems_io_initialize( major, 0, NULL );
7314: e3a00009 mov r0, #9
}
7318: e8bd8010 pop {r4, pc}
if ( rtems_io_is_empty_table( table ) )
break;
}
/* Assigns invalid value in case of failure */
*major = m;
731c: e5824000 str r4, [r2] <== NOT EXECUTED
if ( major == 0 ) {
rtems_status_code sc = rtems_io_obtain_major_number( registered_major );
if ( sc != RTEMS_SUCCESSFUL ) {
_Thread_Enable_dispatch();
7320: eb000669 bl 8ccc <_Thread_Enable_dispatch>
7324: e3a00005 mov r0, #5
return sc;
7328: e8bd8010 pop {r4, pc}
static inline bool rtems_io_is_empty_table(
const rtems_driver_address_table *table
)
{
return table->initialization_entry == NULL && table->open_entry == NULL;
732c: e59c3004 ldr r3, [ip, #4]
7330: e3530000 cmp r3, #0
7334: 1afffff0 bne 72fc <rtems_io_register_driver+0x10c>
if ( !rtems_io_is_empty_table( table ) ) {
_Thread_Enable_dispatch();
return RTEMS_RESOURCE_IN_USE;
}
*registered_major = major;
7338: e5824000 str r4, [r2]
733c: eaffffdb b 72b0 <rtems_io_register_driver+0xc0>
000021c4 <rtems_libio_init>:
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
21c4: e92d4010 push {r4, lr}
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
21c8: e59f40b4 ldr r4, [pc, #180] ; 2284 <rtems_libio_init+0xc0>
21cc: e5940000 ldr r0, [r4]
21d0: e3500000 cmp r0, #0
*
* Called by BSP startup code to initialize the libio subsystem.
*/
void rtems_libio_init( void )
{
21d4: e24dd004 sub sp, sp, #4
rtems_status_code rc;
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
21d8: 0a000016 beq 2238 <rtems_libio_init+0x74>
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
21dc: e3a01040 mov r1, #64 ; 0x40
21e0: ebffff1a bl 1e50 <calloc>
21e4: e59f309c ldr r3, [pc, #156] ; 2288 <rtems_libio_init+0xc4>
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
21e8: e3500000 cmp r0, #0
uint32_t i;
rtems_libio_t *iop;
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
21ec: e5830000 str r0, [r3]
21f0: e1a02000 mov r2, r0
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
21f4: 0a000020 beq 227c <rtems_libio_init+0xb8>
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
21f8: e5941000 ldr r1, [r4]
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
21fc: e59f3088 ldr r3, [pc, #136] ; 228c <rtems_libio_init+0xc8>
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
2200: e3510001 cmp r1, #1
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
2204: e5830000 str r0, [r3]
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
2208: 9a000008 bls 2230 <rtems_libio_init+0x6c>
220c: e2803040 add r3, r0, #64 ; 0x40
2210: e3a02001 mov r2, #1
iop->data1 = iop + 1;
2214: e2822001 add r2, r2, #1
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
2218: e1520001 cmp r2, r1
iop->data1 = iop + 1;
221c: e503300c str r3, [r3, #-12]
2220: e2833040 add r3, r3, #64 ; 0x40
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
iop = rtems_libio_iop_freelist = rtems_libio_iops;
for (i = 0 ; (i + 1) < rtems_libio_number_iops ; i++, iop++)
2224: 1afffffa bne 2214 <rtems_libio_init+0x50>
2228: e2422001 sub r2, r2, #1
222c: e0802302 add r2, r0, r2, lsl #6
iop->data1 = iop + 1;
iop->data1 = NULL;
2230: e3a03000 mov r3, #0
2234: e5823034 str r3, [r2, #52] ; 0x34
/*
* Create the binary semaphore used to provide mutual exclusion
* on the IOP Table.
*/
rc = rtems_semaphore_create(
2238: e59fc050 ldr ip, [pc, #80] ; 2290 <rtems_libio_init+0xcc>
223c: e59f0050 ldr r0, [pc, #80] ; 2294 <rtems_libio_init+0xd0>
2240: e3a01001 mov r1, #1
2244: e3a02054 mov r2, #84 ; 0x54
2248: e3a03000 mov r3, #0
224c: e58dc000 str ip, [sp]
2250: eb000cba bl 5540 <rtems_semaphore_create>
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
2254: e3500000 cmp r0, #0
2258: 1a000006 bne 2278 <rtems_libio_init+0xb4>
/*
* Initialize the base file system infrastructure.
*/
if (rtems_fs_init_helper)
225c: e59f3034 ldr r3, [pc, #52] ; 2298 <rtems_libio_init+0xd4>
2260: e5933000 ldr r3, [r3]
2264: e3530000 cmp r3, #0
(* rtems_fs_init_helper)();
2268: 11a0e00f movne lr, pc
226c: 112fff13 bxne r3
}
2270: e28dd004 add sp, sp, #4
2274: e8bd8010 pop {r4, pc}
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_libio_semaphore
);
if ( rc != RTEMS_SUCCESSFUL )
rtems_fatal_error_occurred( rc );
2278: eb000ed8 bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
if (rtems_libio_number_iops > 0)
{
rtems_libio_iops = (rtems_libio_t *) calloc(rtems_libio_number_iops,
sizeof(rtems_libio_t));
if (rtems_libio_iops == NULL)
rtems_fatal_error_occurred(RTEMS_NO_MEMORY);
227c: e280001a add r0, r0, #26 <== NOT EXECUTED
2280: eb000ed6 bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
0002a4dc <rtems_libio_set_private_env>:
rtems_filesystem_freenode( &env->root_directory);
free(env);
}
}
rtems_status_code rtems_libio_set_private_env(void) {
2a4dc: e92d40f0 push {r4, r5, r6, r7, lr}
rtems_status_code sc;
rtems_id task_id;
rtems_filesystem_location_info_t loc;
sc=rtems_task_ident(RTEMS_SELF,0,&task_id);
2a4e0: e3a00000 mov r0, #0
rtems_filesystem_freenode( &env->root_directory);
free(env);
}
}
rtems_status_code rtems_libio_set_private_env(void) {
2a4e4: e24dd01c sub sp, sp, #28
rtems_status_code sc;
rtems_id task_id;
rtems_filesystem_location_info_t loc;
sc=rtems_task_ident(RTEMS_SELF,0,&task_id);
2a4e8: e1a01000 mov r1, r0 2a4ec: e28d2018 add r2, sp, #24 2a4f0: eb0004d0 bl 2b838 <rtems_task_ident>
if (sc != RTEMS_SUCCESSFUL) return sc;
2a4f4: e2505000 subs r5, r0, #0
2a4f8: 1a000025 bne 2a594 <rtems_libio_set_private_env+0xb8>
/* Only for the first time a malloc is necesary */
if (rtems_current_user_env==&rtems_global_user_env) {
2a4fc: e59f70d8 ldr r7, [pc, #216] ; 2a5dc <rtems_libio_set_private_env+0x100> 2a500: e59f30d8 ldr r3, [pc, #216] ; 2a5e0 <rtems_libio_set_private_env+0x104> 2a504: e5976000 ldr r6, [r7] 2a508: e1560003 cmp r6, r3
2a50c: 0a000023 beq 2a5a0 <rtems_libio_set_private_env+0xc4>
return sc;
}
rtems_current_user_env = tmp;
};
*rtems_current_user_env = rtems_global_user_env; /* get the global values*/
2a510: e59f10c8 ldr r1, [pc, #200] ; 2a5e0 <rtems_libio_set_private_env+0x104> 2a514: e3a02048 mov r2, #72 ; 0x48 2a518: e1a00006 mov r0, r6 2a51c: eb006f63 bl 462b0 <memcpy>
rtems_current_user_env->task_id=task_id; /* mark the local values*/
2a520: e59d3018 ldr r3, [sp, #24]
* what we are trying to do here is forking off
* clones. The reason is a pathloc can be allocated by the
* file system and needs to be freed when deleting the environment.
*/
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
2a524: e3a05000 mov r5, #0 2a528: e28d4004 add r4, sp, #4
}
rtems_current_user_env = tmp;
};
*rtems_current_user_env = rtems_global_user_env; /* get the global values*/
rtems_current_user_env->task_id=task_id; /* mark the local values*/
2a52c: e5863000 str r3, [r6]
* what we are trying to do here is forking off
* clones. The reason is a pathloc can be allocated by the
* file system and needs to be freed when deleting the environment.
*/
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
2a530: e3a01001 mov r1, #1 2a534: e1a03004 mov r3, r4 2a538: e1a02005 mov r2, r5 2a53c: e59f00a0 ldr r0, [pc, #160] ; 2a5e4 <rtems_libio_set_private_env+0x108>
rtems_filesystem_root = loc;
2a540: e1a06004 mov r6, r4
* what we are trying to do here is forking off
* clones. The reason is a pathloc can be allocated by the
* file system and needs to be freed when deleting the environment.
*/
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
2a544: e58d5000 str r5, [sp] 2a548: ebff75e6 bl 7ce8 <rtems_filesystem_evaluate_path>
rtems_filesystem_root = loc;
2a54c: e597c000 ldr ip, [r7]
2a550: e8b6000f ldm r6!, {r0, r1, r2, r3}
2a554: e28cc018 add ip, ip, #24
2a558: e8ac000f stmia ip!, {r0, r1, r2, r3}
2a55c: e5963000 ldr r3, [r6]
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
2a560: e3a01001 mov r1, #1
* clones. The reason is a pathloc can be allocated by the
* file system and needs to be freed when deleting the environment.
*/
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
rtems_filesystem_root = loc;
2a564: e58c3000 str r3, [ip]
rtems_filesystem_evaluate_path("/", 1, 0, &loc, 0);
2a568: e1a02005 mov r2, r5 2a56c: e1a03004 mov r3, r4 2a570: e59f006c ldr r0, [pc, #108] ; 2a5e4 <rtems_libio_set_private_env+0x108> 2a574: e58d5000 str r5, [sp] 2a578: ebff75da bl 7ce8 <rtems_filesystem_evaluate_path>
rtems_filesystem_current = loc;
2a57c: e597c000 ldr ip, [r7]
2a580: e8b4000f ldm r4!, {r0, r1, r2, r3}
2a584: e28cc004 add ip, ip, #4
2a588: e8ac000f stmia ip!, {r0, r1, r2, r3}
2a58c: e5963000 ldr r3, [r6]
2a590: e58c3000 str r3, [ip]
return RTEMS_SUCCESSFUL;
}
2a594: e1a00005 mov r0, r5
2a598: e28dd01c add sp, sp, #28
2a59c: e8bd80f0 pop {r4, r5, r6, r7, pc}
sc=rtems_task_ident(RTEMS_SELF,0,&task_id);
if (sc != RTEMS_SUCCESSFUL) return sc;
/* Only for the first time a malloc is necesary */
if (rtems_current_user_env==&rtems_global_user_env) {
rtems_user_env_t *tmp = malloc(sizeof(rtems_user_env_t));
2a5a0: e3a00048 mov r0, #72 ; 0x48 2a5a4: ebff77b5 bl 8480 <malloc>
if (!tmp)
2a5a8: e2506000 subs r6, r0, #0 2a5ac: 03a0501a moveq r5, #26
2a5b0: 0afffff7 beq 2a594 <rtems_libio_set_private_env+0xb8>
#ifdef HAVE_USERENV_REFCNT
tmp->refcnt = 1;
#endif
sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,(void(*)(void *))free_user_env);
2a5b4: e1a00005 mov r0, r5 2a5b8: e1a01007 mov r1, r7 2a5bc: e59f2024 ldr r2, [pc, #36] ; 2a5e8 <rtems_libio_set_private_env+0x10c> 2a5c0: eb000544 bl 2bad8 <rtems_task_variable_add>
if (sc != RTEMS_SUCCESSFUL) {
2a5c4: e2505000 subs r5, r0, #0
* not initialized yet
*/
free(tmp);
return sc;
}
rtems_current_user_env = tmp;
2a5c8: 05876000 streq r6, [r7]
#ifdef HAVE_USERENV_REFCNT
tmp->refcnt = 1;
#endif
sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,(void(*)(void *))free_user_env);
if (sc != RTEMS_SUCCESSFUL) {
2a5cc: 0affffcf beq 2a510 <rtems_libio_set_private_env+0x34>
/* don't use free_user_env because the pathlocs are
* not initialized yet
*/
free(tmp);
2a5d0: e1a00006 mov r0, r6 <== NOT EXECUTED 2a5d4: ebff75e5 bl 7d70 <free> <== NOT EXECUTED
return sc;
2a5d8: eaffffed b 2a594 <rtems_libio_set_private_env+0xb8> <== NOT EXECUTED
0002a42c <rtems_libio_share_private_env>:
* b) mutex access to rtems_filesystem_current, rtems_filesytem_root
* while changing any of those (chdir(), chroot()).
*/
#ifndef HAVE_USERENV_REFCNT
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) {
2a42c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
2a430: e1a05000 mov r5, r0 <== NOT EXECUTED
2a434: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
rtems_status_code sc;
rtems_user_env_t * shared_user_env;
rtems_id current_task_id;
sc=rtems_task_ident(RTEMS_SELF,0,¤t_task_id);
2a438: e3a00000 mov r0, #0 <== NOT EXECUTED 2a43c: e1a01000 mov r1, r0 <== NOT EXECUTED 2a440: e1a0200d mov r2, sp <== NOT EXECUTED 2a444: eb0004fb bl 2b838 <rtems_task_ident> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) return sc;
2a448: e2503000 subs r3, r0, #0 <== NOT EXECUTED 2a44c: 1a00000d bne 2a488 <rtems_libio_share_private_env+0x5c> <== NOT EXECUTED
if (rtems_current_user_env->task_id==current_task_id) {
2a450: e59f4078 ldr r4, [pc, #120] ; 2a4d0 <rtems_libio_share_private_env+0xa4><== NOT EXECUTED 2a454: e5946000 ldr r6, [r4] <== NOT EXECUTED 2a458: e59d3000 ldr r3, [sp] <== NOT EXECUTED 2a45c: e5962000 ldr r2, [r6] <== NOT EXECUTED 2a460: e1520003 cmp r2, r3 <== NOT EXECUTED 2a464: 0a00000a beq 2a494 <rtems_libio_share_private_env+0x68> <== NOT EXECUTED
free_user_env(tmp);
};
/* AT THIS POINT, rtems_current_user_env is DANGLING */
sc = rtems_task_variable_get(task_id,(void*)&rtems_current_user_env,
2a468: e1a00005 mov r0, r5 <== NOT EXECUTED 2a46c: e59f105c ldr r1, [pc, #92] ; 2a4d0 <rtems_libio_share_private_env+0xa4><== NOT EXECUTED 2a470: e28d2004 add r2, sp, #4 <== NOT EXECUTED 2a474: eb0005ea bl 2bc24 <rtems_task_variable_get> <== NOT EXECUTED
(void*)&shared_user_env ); if (sc != RTEMS_SUCCESSFUL)
2a478: e2503000 subs r3, r0, #0 <== NOT EXECUTED 2a47c: 0a00000b beq 2a4b0 <rtems_libio_share_private_env+0x84> <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
bailout:
/* fallback to the global env */
rtems_current_user_env = &rtems_global_user_env;
2a480: e59f204c ldr r2, [pc, #76] ; 2a4d4 <rtems_libio_share_private_env+0xa8><== NOT EXECUTED 2a484: e5842000 str r2, [r4] <== NOT EXECUTED
return sc; }
2a488: e1a00003 mov r0, r3 <== NOT EXECUTED
2a48c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
2a490: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) return sc;
if (rtems_current_user_env->task_id==current_task_id) {
/* kill the current user env & task_var*/
rtems_user_env_t *tmp = rtems_current_user_env;
sc = rtems_task_variable_delete(RTEMS_SELF,(void*)&rtems_current_user_env);
2a494: e1a01004 mov r1, r4 <== NOT EXECUTED 2a498: eb0005bb bl 2bb8c <rtems_task_variable_delete> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) return sc;
2a49c: e2503000 subs r3, r0, #0 <== NOT EXECUTED 2a4a0: 1afffff8 bne 2a488 <rtems_libio_share_private_env+0x5c> <== NOT EXECUTED
free_user_env(tmp);
2a4a4: e1a00006 mov r0, r6 <== NOT EXECUTED 2a4a8: ebffffc6 bl 2a3c8 <free_user_env> <== NOT EXECUTED 2a4ac: eaffffed b 2a468 <rtems_libio_share_private_env+0x3c> <== NOT EXECUTED
sc = rtems_task_variable_get(task_id,(void*)&rtems_current_user_env,
(void*)&shared_user_env );
if (sc != RTEMS_SUCCESSFUL)
goto bailout;
sc = rtems_task_variable_add(RTEMS_SELF,(void*)&rtems_current_user_env,free_user_env);
2a4b0: e59f1018 ldr r1, [pc, #24] ; 2a4d0 <rtems_libio_share_private_env+0xa4><== NOT EXECUTED 2a4b4: e59f201c ldr r2, [pc, #28] ; 2a4d8 <rtems_libio_share_private_env+0xac><== NOT EXECUTED 2a4b8: eb000586 bl 2bad8 <rtems_task_variable_add> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2a4bc: e2503000 subs r3, r0, #0 <== NOT EXECUTED 2a4c0: 1affffee bne 2a480 <rtems_libio_share_private_env+0x54> <== NOT EXECUTED
goto bailout;
/* the current_user_env is the same pointer that remote env */
rtems_current_user_env = shared_user_env;
2a4c4: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 2a4c8: e5842000 str r2, [r4] <== NOT EXECUTED
/* increase the reference count */
#ifdef HAVE_USERENV_REFCNT
rtems_current_user_env->refcnt++;
#endif
return RTEMS_SUCCESSFUL;
2a4cc: eaffffed b 2a488 <rtems_libio_share_private_env+0x5c> <== NOT EXECUTED
0000857c <rtems_malloc_statistics_at_free>:
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
857c: e92d4800 push {fp, lr} <== NOT EXECUTED
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
8580: e59f3040 ldr r3, [pc, #64] ; 85c8 <rtems_malloc_statistics_at_free+0x4c><== NOT EXECUTED
* size and thus we skip updating the statistics.
*/
static void rtems_malloc_statistics_at_free(
void *pointer
)
{
8584: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
8588: e1a01000 mov r1, r0 <== NOT EXECUTED
uintptr_t size;
if (_Protected_heap_Get_block_size(RTEMS_Malloc_Heap, pointer, &size) ) {
858c: e1a0200d mov r2, sp <== NOT EXECUTED
8590: e5930000 ldr r0, [r3] <== NOT EXECUTED
8594: eb001763 bl e328 <_Protected_heap_Get_block_size> <== NOT EXECUTED
8598: e3500000 cmp r0, #0 <== NOT EXECUTED
859c: 0a000007 beq 85c0 <rtems_malloc_statistics_at_free+0x44> <== NOT EXECUTED
MSBUMP(lifetime_freed, size);
85a0: e59f3024 ldr r3, [pc, #36] ; 85cc <rtems_malloc_statistics_at_free+0x50><== NOT EXECUTED
85a4: e59d0000 ldr r0, [sp] <== NOT EXECUTED
85a8: e283c024 add ip, r3, #36 ; 0x24 <== NOT EXECUTED
85ac: e89c1800 ldm ip, {fp, ip} <== NOT EXECUTED
85b0: e09b1000 adds r1, fp, r0 <== NOT EXECUTED
85b4: e2ac2000 adc r2, ip, #0 <== NOT EXECUTED
85b8: e5831024 str r1, [r3, #36] ; 0x24 <== NOT EXECUTED
85bc: e5832028 str r2, [r3, #40] ; 0x28 <== NOT EXECUTED
} }
85c0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
85c4: e8bd8800 pop {fp, pc} <== NOT EXECUTED
00009490 <rtems_mkdir>:
return (retval);
}
int
rtems_mkdir(const char *path, mode_t mode)
{
9490: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
9494: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED
9498: e1a0a001 mov sl, r1 <== NOT EXECUTED
int success = 0; char *dup_path = strdup(path);
949c: eb010030 bl 49564 <strdup> <== NOT EXECUTED
if (dup_path != NULL) {
94a0: e2506000 subs r6, r0, #0 <== NOT EXECUTED
94a4: 0a00005e beq 9624 <rtems_mkdir+0x194> <== NOT EXECUTED
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
94a8: e5d63000 ldrb r3, [r6] <== NOT EXECUTED
94ac: e353002f cmp r3, #47 ; 0x2f <== NOT EXECUTED
++p;
94b0: e3a07000 mov r7, #0 <== NOT EXECUTED
94b4: 05d63001 ldrbeq r3, [r6, #1] <== NOT EXECUTED
char *p;
p = path;
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
94b8: 11a05006 movne r5, r6 <== NOT EXECUTED
++p;
94bc: 02865001 addeq r5, r6, #1 <== NOT EXECUTED
94c0: e3a02001 mov r2, #1 <== NOT EXECUTED
retval = 0; break; } } if (!last) *p = '/';
94c4: e3a0802f mov r8, #47 ; 0x2f <== NOT EXECUTED
94c8: e1a09007 mov r9, r7 <== NOT EXECUTED
}
if (last)
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
94cc: e1a0b00d mov fp, sp <== NOT EXECUTED
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
94d0: e3530000 cmp r3, #0 <== NOT EXECUTED
last = 1; else if (p[0] != '/') continue; *p = '\0';
94d4: 05c53000 strbeq r3, [r5] <== NOT EXECUTED
94d8: 03a04001 moveq r4, #1 <== NOT EXECUTED
oumask = 0;
retval = 1;
if (p[0] == '/') /* Skip leading '/'. */
++p;
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
94dc: 0a000006 beq 94fc <rtems_mkdir+0x6c> <== NOT EXECUTED
last = 1; else if (p[0] != '/')
94e0: e353002f cmp r3, #47 ; 0x2f <== NOT EXECUTED
retval = 0; break; } } if (!last) *p = '/';
94e4: 15f53001 ldrbne r3, [r5, #1]! <== NOT EXECUTED
94e8: 1afffff8 bne 94d0 <rtems_mkdir+0x40> <== NOT EXECUTED
if (p[0] == '\0') last = 1; else if (p[0] != '/') continue; *p = '\0'; if (!last && p[1] == '\0')
94ec: e5d54001 ldrb r4, [r5, #1] <== NOT EXECUTED
for (first = 1, last = 0; !last ; ++p) {
if (p[0] == '\0')
last = 1;
else if (p[0] != '/')
continue;
*p = '\0';
94f0: e5c59000 strb r9, [r5] <== NOT EXECUTED
if (!last && p[1] == '\0')
94f4: e2744001 rsbs r4, r4, #1 <== NOT EXECUTED
94f8: 33a04000 movcc r4, #0 <== NOT EXECUTED
last = 1;
if (first) {
94fc: e3520000 cmp r2, #0 <== NOT EXECUTED
9500: 1a000031 bne 95cc <rtems_mkdir+0x13c> <== NOT EXECUTED
oumask = umask(0); numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask); first = 0; } if (last)
9504: e3540000 cmp r4, #0 <== NOT EXECUTED
9508: 03a01f7f moveq r1, #508 ; 0x1fc <== NOT EXECUTED
950c: 02811003 addeq r1, r1, #3 <== NOT EXECUTED
9510: 1a000011 bne 955c <rtems_mkdir+0xcc> <== NOT EXECUTED
(void)umask(oumask);
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
9514: e1a00006 mov r0, r6 <== NOT EXECUTED
9518: ebfffc59 bl 8684 <mkdir> <== NOT EXECUTED
951c: e3500000 cmp r0, #0 <== NOT EXECUTED
9520: ba000014 blt 9578 <rtems_mkdir+0xe8> <== NOT EXECUTED
} else {
retval = 0;
break;
}
}
if (!last)
9524: e3540000 cmp r4, #0 <== NOT EXECUTED
9528: 0a000007 beq 954c <rtems_mkdir+0xbc> <== NOT EXECUTED
if (p[0] == '\0') last = 1; else if (p[0] != '/') continue; *p = '\0'; if (!last && p[1] == '\0')
952c: e3a04001 mov r4, #1 <== NOT EXECUTED
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
9530: e1a00006 mov r0, r6 <== NOT EXECUTED
9534: ebfffa0d bl 7d70 <free> <== NOT EXECUTED
}
return success != 0 ? 0 : -1;
9538: e3540000 cmp r4, #0 <== NOT EXECUTED
953c: 13a00000 movne r0, #0 <== NOT EXECUTED
9540: 0a000037 beq 9624 <rtems_mkdir+0x194> <== NOT EXECUTED
}
9544: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
9548: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
retval = 0; break; } } if (!last) *p = '/';
954c: e5c58000 strb r8, [r5] <== NOT EXECUTED
9550: e3a02000 mov r2, #0 <== NOT EXECUTED
9554: e5f53001 ldrb r3, [r5, #1]! <== NOT EXECUTED
9558: eaffffdc b 94d0 <rtems_mkdir+0x40> <== NOT EXECUTED
numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask); first = 0; } if (last) (void)umask(oumask);
955c: e1a00007 mov r0, r7 <== NOT EXECUTED
9560: eb0007f3 bl b534 <umask> <== NOT EXECUTED
9564: e1a0100a mov r1, sl <== NOT EXECUTED
if (mkdir(path, last ? omode : S_IRWXU | S_IRWXG | S_IRWXO) < 0) {
9568: e1a00006 mov r0, r6 <== NOT EXECUTED
956c: ebfffc44 bl 8684 <mkdir> <== NOT EXECUTED
9570: e3500000 cmp r0, #0 <== NOT EXECUTED
9574: aaffffea bge 9524 <rtems_mkdir+0x94> <== NOT EXECUTED
if (errno == EEXIST || errno == EISDIR) {
9578: eb00e69c bl 42ff0 <__errno> <== NOT EXECUTED
957c: e5903000 ldr r3, [r0] <== NOT EXECUTED
9580: e3530011 cmp r3, #17 <== NOT EXECUTED
9584: 0a000003 beq 9598 <rtems_mkdir+0x108> <== NOT EXECUTED
9588: eb00e698 bl 42ff0 <__errno> <== NOT EXECUTED
958c: e5903000 ldr r3, [r0] <== NOT EXECUTED
9590: e3530015 cmp r3, #21 <== NOT EXECUTED
9594: 1a000024 bne 962c <rtems_mkdir+0x19c> <== NOT EXECUTED
if (stat(path, &sb) < 0) {
9598: e1a00006 mov r0, r6 <== NOT EXECUTED
959c: e1a0100d mov r1, sp <== NOT EXECUTED
95a0: eb000024 bl 9638 <stat> <== NOT EXECUTED
95a4: e3500000 cmp r0, #0 <== NOT EXECUTED
95a8: ba00001f blt 962c <rtems_mkdir+0x19c> <== NOT EXECUTED
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
95ac: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
95b0: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED
95b4: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
95b8: 1a000009 bne 95e4 <rtems_mkdir+0x154> <== NOT EXECUTED
else errno = ENOTDIR; retval = 0; break; } if (last)
95bc: e3540000 cmp r4, #0 <== NOT EXECUTED
95c0: 0affffe1 beq 954c <rtems_mkdir+0xbc> <== NOT EXECUTED
95c4: e3a04002 mov r4, #2 <== NOT EXECUTED
95c8: eaffffd8 b 9530 <rtems_mkdir+0xa0> <== NOT EXECUTED
* mkdir [-m mode] dir * * We change the user's umask and then restore it, * instead of doing chmod's. */ oumask = umask(0);
95cc: e3a00000 mov r0, #0 <== NOT EXECUTED
95d0: eb0007d7 bl b534 <umask> <== NOT EXECUTED
95d4: e1a07000 mov r7, r0 <== NOT EXECUTED
numask = oumask & ~(S_IWUSR | S_IXUSR); (void)umask(numask);
95d8: e3c000c0 bic r0, r0, #192 ; 0xc0 <== NOT EXECUTED
95dc: eb0007d4 bl b534 <umask> <== NOT EXECUTED
95e0: eaffffc7 b 9504 <rtems_mkdir+0x74> <== NOT EXECUTED
if (errno == EEXIST || errno == EISDIR) {
if (stat(path, &sb) < 0) {
retval = 0;
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
95e4: e3540000 cmp r4, #0 <== NOT EXECUTED
95e8: 0a000006 beq 9608 <rtems_mkdir+0x178> <== NOT EXECUTED
errno = EEXIST;
95ec: eb00e67f bl 42ff0 <__errno> <== NOT EXECUTED
95f0: e3a03011 mov r3, #17 <== NOT EXECUTED
95f4: e5803000 str r3, [r0] <== NOT EXECUTED
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
95f8: e1a00006 mov r0, r6 <== NOT EXECUTED
95fc: ebfff9db bl 7d70 <free> <== NOT EXECUTED
9600: e3e00000 mvn r0, #0 <== NOT EXECUTED
9604: eaffffce b 9544 <rtems_mkdir+0xb4> <== NOT EXECUTED
break;
} else if (!S_ISDIR(sb.st_mode)) {
if (last)
errno = EEXIST;
else
errno = ENOTDIR;
9608: eb00e678 bl 42ff0 <__errno> <== NOT EXECUTED
960c: e3a03014 mov r3, #20 <== NOT EXECUTED
9610: e5803000 str r3, [r0] <== NOT EXECUTED
} if (!last) *p = '/'; } if (!first && !last) (void)umask(oumask);
9614: e1a00007 mov r0, r7 <== NOT EXECUTED
9618: eb0007c5 bl b534 <umask> <== NOT EXECUTED
int success = 0;
char *dup_path = strdup(path);
if (dup_path != NULL) {
success = build(dup_path, mode);
free(dup_path);
961c: e1a00006 mov r0, r6 <== NOT EXECUTED
9620: ebfff9d2 bl 7d70 <free> <== NOT EXECUTED
} if (!last) *p = '/'; } if (!first && !last) (void)umask(oumask);
9624: e3e00000 mvn r0, #0 <== NOT EXECUTED
9628: eaffffc5 b 9544 <rtems_mkdir+0xb4> <== NOT EXECUTED
} } if (!last) *p = '/'; } if (!first && !last)
962c: e3540000 cmp r4, #0 <== NOT EXECUTED
9630: 0afffff7 beq 9614 <rtems_mkdir+0x184> <== NOT EXECUTED
9634: eafffff8 b 961c <rtems_mkdir+0x18c> <== NOT EXECUTED
00020b5c <rtems_nvdisk_crc16_gen_factors>:
* @relval RTEMS_SUCCESSFUL The table was generated.
* @retval RTEMS_NO_MEMORY The table could not be allocated from the heap.
*/
rtems_status_code
rtems_nvdisk_crc16_gen_factors (uint16_t pattern)
{
20b5c: e92d4010 push {r4, lr} <== NOT EXECUTED
20b60: e1a04800 lsl r4, r0, #16 <== NOT EXECUTED
uint32_t b;
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
20b64: e3a00c02 mov r0, #512 ; 0x200 <== NOT EXECUTED 20b68: ebff9e44 bl 8480 <malloc> <== NOT EXECUTED 20b6c: e59f3058 ldr r3, [pc, #88] ; 20bcc <rtems_nvdisk_crc16_gen_factors+0x70><== NOT EXECUTED
if (!rtems_nvdisk_crc16_factor)
20b70: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_status_code
rtems_nvdisk_crc16_gen_factors (uint16_t pattern)
{
uint32_t b;
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
20b74: e5830008 str r0, [r3, #8] <== NOT EXECUTED
* @relval RTEMS_SUCCESSFUL The table was generated.
* @retval RTEMS_NO_MEMORY The table could not be allocated from the heap.
*/
rtems_status_code
rtems_nvdisk_crc16_gen_factors (uint16_t pattern)
{
20b78: e1a04824 lsr r4, r4, #16 <== NOT EXECUTED
uint32_t b;
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_nvdisk_crc16_factor)
20b7c: 0280001a addeq r0, r0, #26 <== NOT EXECUTED
20b80: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
20b84: e3a01000 mov r1, #0 <== NOT EXECUTED
20b88: e1a03801 lsl r3, r1, #16 <== NOT EXECUTED
20b8c: e1a03823 lsr r3, r3, #16 <== NOT EXECUTED
20b90: e3a02007 mov r2, #7 <== NOT EXECUTED
20b94: ea000000 b 20b9c <rtems_nvdisk_crc16_gen_factors+0x40> <== NOT EXECUTED
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
20b98: e2422001 sub r2, r2, #1 <== NOT EXECUTED
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
20b9c: e3130001 tst r3, #1 <== NOT EXECUTED 20ba0: 102430a3 eorne r3, r4, r3, lsr #1 <== NOT EXECUTED 20ba4: 01a030a3 lsreq r3, r3, #1 <== NOT EXECUTED
for (b = 0; b < 256; b++)
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
20ba8: e3520000 cmp r2, #0 <== NOT EXECUTED 20bac: 1afffff9 bne 20b98 <rtems_nvdisk_crc16_gen_factors+0x3c> <== NOT EXECUTED
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
rtems_nvdisk_crc16_factor[b] = v & 0xffff;
20bb0: e1a0c081 lsl ip, r1, #1 <== NOT EXECUTED
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_nvdisk_crc16_factor)
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
20bb4: e2811001 add r1, r1, #1 <== NOT EXECUTED 20bb8: e3510c01 cmp r1, #256 ; 0x100 <== NOT EXECUTED
{
uint32_t i;
uint16_t v = b;
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
rtems_nvdisk_crc16_factor[b] = v & 0xffff;
20bbc: e18030bc strh r3, [r0, ip] <== NOT EXECUTED
rtems_nvdisk_crc16_factor = malloc (sizeof (uint16_t) * 256);
if (!rtems_nvdisk_crc16_factor)
return RTEMS_NO_MEMORY;
for (b = 0; b < 256; b++)
20bc0: 1afffff0 bne 20b88 <rtems_nvdisk_crc16_gen_factors+0x2c> <== NOT EXECUTED 20bc4: e1a00002 mov r0, r2 <== NOT EXECUTED
for (i = 8; i--;)
v = v & 1 ? (v >> 1) ^ pattern : v >> 1;
rtems_nvdisk_crc16_factor[b] = v & 0xffff;
}
return RTEMS_SUCCESSFUL;
}
20bc8: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0002043c <rtems_nvdisk_error>:
* @param ... The arguments for the format text.
* @return int The number of bytes written to the output.
*/
static int
rtems_nvdisk_error (const char *format, ...)
{
2043c: e92d000f push {r0, r1, r2, r3} <== NOT EXECUTED
20440: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
int ret; va_list args; va_start (args, format); fprintf (stderr, "nvdisk:error:");
20444: e59f4068 ldr r4, [pc, #104] ; 204b4 <rtems_nvdisk_error+0x78><== NOT EXECUTED 20448: e5943000 ldr r3, [r4] <== NOT EXECUTED
* @param ... The arguments for the format text.
* @return int The number of bytes written to the output.
*/
static int
rtems_nvdisk_error (const char *format, ...)
{
2044c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
int ret; va_list args; va_start (args, format);
20450: e28dc014 add ip, sp, #20 <== NOT EXECUTED
fprintf (stderr, "nvdisk:error:");
20454: e593300c ldr r3, [r3, #12] <== NOT EXECUTED 20458: e3a01001 mov r1, #1 <== NOT EXECUTED 2045c: e3a0200d mov r2, #13 <== NOT EXECUTED 20460: e59f0050 ldr r0, [pc, #80] ; 204b8 <rtems_nvdisk_error+0x7c><== NOT EXECUTED
static int
rtems_nvdisk_error (const char *format, ...)
{
int ret;
va_list args;
va_start (args, format);
20464: e58dc000 str ip, [sp] <== NOT EXECUTED
fprintf (stderr, "nvdisk:error:");
20468: eb00921d bl 44ce4 <fwrite> <== NOT EXECUTED
ret = vfprintf (stderr, format, args);
2046c: e5943000 ldr r3, [r4] <== NOT EXECUTED 20470: e59d2000 ldr r2, [sp] <== NOT EXECUTED 20474: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 20478: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 2047c: eb00c5f8 bl 51c64 <vfprintf> <== NOT EXECUTED
fprintf (stderr, "\n");
20480: e5943000 ldr r3, [r4] <== NOT EXECUTED
{
int ret;
va_list args;
va_start (args, format);
fprintf (stderr, "nvdisk:error:");
ret = vfprintf (stderr, format, args);
20484: e1a05000 mov r5, r0 <== NOT EXECUTED
fprintf (stderr, "\n");
20488: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 2048c: e3a0000a mov r0, #10 <== NOT EXECUTED 20490: eb008d69 bl 43a3c <fputc> <== NOT EXECUTED
fflush (stderr);
20494: e5943000 ldr r3, [r4] <== NOT EXECUTED 20498: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 2049c: eb008bc6 bl 433bc <fflush> <== NOT EXECUTED
va_end (args); return ret; }
204a0: e1a00005 mov r0, r5 <== NOT EXECUTED
204a4: e28dd004 add sp, sp, #4 <== NOT EXECUTED
204a8: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
204ac: e28dd010 add sp, sp, #16 <== NOT EXECUTED
204b0: e12fff1e bx lr <== NOT EXECUTED
000204bc <rtems_nvdisk_get_device>:
static rtems_nvdisk_device_ctl*
rtems_nvdisk_get_device (rtems_nvdisk* nvd, uint32_t block)
{
uint32_t device;
if (block >= nvd->block_count)
204bc: e5902010 ldr r2, [r0, #16] <== NOT EXECUTED 204c0: e1520001 cmp r2, r1 <== NOT EXECUTED
/**
* Map a block to a device.
*/
static rtems_nvdisk_device_ctl*
rtems_nvdisk_get_device (rtems_nvdisk* nvd, uint32_t block)
{
204c4: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
204c8: e1a03001 mov r3, r1 <== NOT EXECUTED
uint32_t device;
if (block >= nvd->block_count)
204cc: 9a000017 bls 20530 <rtems_nvdisk_get_device+0x74> <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
return NULL;
}
for (device = 0; device < nvd->device_count; device++)
204d0: e5904018 ldr r4, [r0, #24] <== NOT EXECUTED 204d4: e3540000 cmp r4, #0 <== NOT EXECUTED 204d8: 0a00000f beq 2051c <rtems_nvdisk_get_device+0x60> <== NOT EXECUTED
uint32_t device;
if (block >= nvd->block_count)
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
return NULL;
204dc: e5902014 ldr r2, [r0, #20] <== NOT EXECUTED 204e0: e3a01000 mov r1, #0 <== NOT EXECUTED
}
for (device = 0; device < nvd->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
if ((block >= dc->block_base) &&
204e4: e592c00c ldr ip, [r2, #12] <== NOT EXECUTED 204e8: e153000c cmp r3, ip <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
return NULL;
}
for (device = 0; device < nvd->device_count; device++)
204ec: e2811001 add r1, r1, #1 <== NOT EXECUTED
uint32_t device;
if (block >= nvd->block_count)
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
return NULL;
204f0: e1a00002 mov r0, r2 <== NOT EXECUTED
}
for (device = 0; device < nvd->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
if ((block >= dc->block_base) &&
204f4: 3a000005 bcc 20510 <rtems_nvdisk_get_device+0x54> <== NOT EXECUTED
204f8: e5926004 ldr r6, [r2, #4] <== NOT EXECUTED
204fc: e5925008 ldr r5, [r2, #8] <== NOT EXECUTED
20500: e08cc006 add ip, ip, r6 <== NOT EXECUTED
20504: e065c00c rsb ip, r5, ip <== NOT EXECUTED
20508: e153000c cmp r3, ip <== NOT EXECUTED
2050c: 38bd8070 popcc {r4, r5, r6, pc} <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
return NULL;
}
for (device = 0; device < nvd->device_count; device++)
20510: e1510004 cmp r1, r4 <== NOT EXECUTED 20514: e2822014 add r2, r2, #20 <== NOT EXECUTED 20518: 3afffff1 bcc 204e4 <rtems_nvdisk_get_device+0x28> <== NOT EXECUTED
if ((block >= dc->block_base) &&
(block < (dc->block_base + dc->pages - dc->pages_desc)))
return dc;
}
rtems_nvdisk_error ("map-block:%d: no device/page map found", block);
2051c: e1a01003 mov r1, r3 <== NOT EXECUTED 20520: e59f0018 ldr r0, [pc, #24] ; 20540 <rtems_nvdisk_get_device+0x84><== NOT EXECUTED 20524: ebffffc4 bl 2043c <rtems_nvdisk_error> <== NOT EXECUTED 20528: e3a00000 mov r0, #0 <== NOT EXECUTED
return NULL;
}
2052c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
{
uint32_t device;
if (block >= nvd->block_count)
{
rtems_nvdisk_error ("read-block: bad block: %d", block);
20530: e59f000c ldr r0, [pc, #12] ; 20544 <rtems_nvdisk_get_device+0x88><== NOT EXECUTED 20534: ebffffc0 bl 2043c <rtems_nvdisk_error> <== NOT EXECUTED 20538: e3a00000 mov r0, #0 <== NOT EXECUTED
return NULL;
2053c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00020bd0 <rtems_nvdisk_initialize>:
*/
rtems_device_driver
rtems_nvdisk_initialize (rtems_device_major_number major,
rtems_device_minor_number minor,
void* arg __attribute__((unused)))
{
20bd0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
20bd4: e24dd03c sub sp, sp, #60 ; 0x3c <== NOT EXECUTED
20bd8: e58d001c str r0, [sp, #28] <== NOT EXECUTED
const rtems_nvdisk_config* c = rtems_nvdisk_configuration;
rtems_nvdisk* nvd;
rtems_status_code sc;
sc = rtems_disk_io_initialize ();
20bdc: ebff967f bl 65e0 <rtems_disk_io_initialize> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
20be0: e2506000 subs r6, r0, #0 <== NOT EXECUTED 20be4: 0a000002 beq 20bf4 <rtems_nvdisk_initialize+0x24> <== NOT EXECUTED
}
rtems_nvdisk_count = rtems_nvdisk_configuration_size;
return RTEMS_SUCCESSFUL;
}
20be8: e1a00006 mov r0, r6 <== NOT EXECUTED
20bec: e28dd03c add sp, sp, #60 ; 0x3c <== NOT EXECUTED
20bf0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
sc = rtems_disk_io_initialize ();
if (sc != RTEMS_SUCCESSFUL)
return sc;
sc = rtems_nvdisk_crc16_gen_factors (0x8408);
20bf4: e3a00b21 mov r0, #33792 ; 0x8400 <== NOT EXECUTED 20bf8: e2800008 add r0, r0, #8 <== NOT EXECUTED 20bfc: ebffffd6 bl 20b5c <rtems_nvdisk_crc16_gen_factors> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
20c00: e2506000 subs r6, r0, #0 <== NOT EXECUTED 20c04: 1afffff7 bne 20be8 <rtems_nvdisk_initialize+0x18> <== NOT EXECUTED
return sc;
rtems_nvdisks = calloc (rtems_nvdisk_configuration_size,
20c08: e59f223c ldr r2, [pc, #572] ; 20e4c <rtems_nvdisk_initialize+0x27c><== NOT EXECUTED 20c0c: e3a01028 mov r1, #40 ; 0x28 <== NOT EXECUTED 20c10: e5920000 ldr r0, [r2] <== NOT EXECUTED 20c14: ebff9ad1 bl 7760 <calloc> <== NOT EXECUTED 20c18: e59fc230 ldr ip, [pc, #560] ; 20e50 <rtems_nvdisk_initialize+0x280><== NOT EXECUTED
sizeof (rtems_nvdisk));
if (!rtems_nvdisks)
20c1c: e3500000 cmp r0, #0 <== NOT EXECUTED
sc = rtems_nvdisk_crc16_gen_factors (0x8408);
if (sc != RTEMS_SUCCESSFUL)
return sc;
rtems_nvdisks = calloc (rtems_nvdisk_configuration_size,
20c20: e1a03000 mov r3, r0 <== NOT EXECUTED 20c24: e58c0004 str r0, [ip, #4] <== NOT EXECUTED
sizeof (rtems_nvdisk));
if (!rtems_nvdisks)
20c28: 0a000079 beq 20e14 <rtems_nvdisk_initialize+0x244> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
20c2c: e59f1218 ldr r1, [pc, #536] ; 20e4c <rtems_nvdisk_initialize+0x27c><== NOT EXECUTED 20c30: e5912000 ldr r2, [r1] <== NOT EXECUTED 20c34: e3520000 cmp r2, #0 <== NOT EXECUTED 20c38: 0a000077 beq 20e1c <rtems_nvdisk_initialize+0x24c> <== NOT EXECUTED 20c3c: e28d2028 add r2, sp, #40 ; 0x28 <== NOT EXECUTED 20c40: e58d6018 str r6, [sp, #24] <== NOT EXECUTED 20c44: e59f5208 ldr r5, [pc, #520] ; 20e54 <rtems_nvdisk_initialize+0x284><== NOT EXECUTED 20c48: e58d6014 str r6, [sp, #20] <== NOT EXECUTED 20c4c: e58d200c str r2, [sp, #12] <== NOT EXECUTED
{
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
20c50: e59fc200 ldr ip, [pc, #512] ; 20e58 <rtems_nvdisk_initialize+0x288><== NOT EXECUTED
20c54: e89c0007 ldm ip, {r0, r1, r2} <== NOT EXECUTED
20c58: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED
20c5c: e8ac0003 stmia ip!, {r0, r1} <== NOT EXECUTED
20c60: e1cc20b0 strh r2, [ip] <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
20c64: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED
uint32_t device;
uint32_t blocks = 0;
nvd = &rtems_nvdisks[minor];
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
20c68: e5dd2031 ldrb r2, [sp, #49] ; 0x31 <== NOT EXECUTED
temp.__overlay.minor = _minor;
20c6c: e59dc014 ldr ip, [sp, #20] <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
20c70: e58d1034 str r1, [sp, #52] ; 0x34 <== NOT EXECUTED
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
nvd = &rtems_nvdisks[minor];
20c74: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED
temp.__overlay.minor = _minor;
20c78: e58dc038 str ip, [sp, #56] ; 0x38 <== NOT EXECUTED
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
20c7c: e082200c add r2, r2, ip <== NOT EXECUTED
char name[] = RTEMS_NVDISK_DEVICE_BASE_NAME "a";
dev_t dev = rtems_filesystem_make_dev_t (major, minor);
uint32_t device;
uint32_t blocks = 0;
nvd = &rtems_nvdisks[minor];
20c80: e0834001 add r4, r3, r1 <== NOT EXECUTED
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
20c84: e5cd2031 strb r2, [sp, #49] ; 0x31 <== NOT EXECUTED
return temp.device;
20c88: e28d2034 add r2, sp, #52 ; 0x34 <== NOT EXECUTED
20c8c: e8920006 ldm r2, {r1, r2} <== NOT EXECUTED
nvd->major = major;
20c90: e59dc01c ldr ip, [sp, #28] <== NOT EXECUTED 20c94: e58d1020 str r1, [sp, #32] <== NOT EXECUTED 20c98: e58d2024 str r2, [sp, #36] ; 0x24 <== NOT EXECUTED
nvd->minor = minor;
20c9c: e28d1014 add r1, sp, #20 <== NOT EXECUTED
20ca0: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
20ca4: e5841004 str r1, [r4, #4] <== NOT EXECUTED
nvd = &rtems_nvdisks[minor];
name [sizeof(RTEMS_NVDISK_DEVICE_BASE_NAME)] += minor;
nvd->major = major;
20ca8: e783c002 str ip, [r3, r2] <== NOT EXECUTED
nvd->minor = minor;
nvd->flags = c->flags;
20cac: e5953000 ldr r3, [r5] <== NOT EXECUTED 20cb0: e5843008 str r3, [r4, #8] <== NOT EXECUTED
nvd->block_size = c->block_size;
20cb4: e515300c ldr r3, [r5, #-12] <== NOT EXECUTED 20cb8: e584300c str r3, [r4, #12] <== NOT EXECUTED
nvd->info_level = c->info_level;
20cbc: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED 20cc0: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
20cc4: e3a01014 mov r1, #20 <== NOT EXECUTED 20cc8: e5150008 ldr r0, [r5, #-8] <== NOT EXECUTED 20ccc: ebff9aa3 bl 7760 <calloc> <== NOT EXECUTED
if (!nvd->devices)
20cd0: e3500000 cmp r0, #0 <== NOT EXECUTED
nvd->minor = minor;
nvd->flags = c->flags;
nvd->block_size = c->block_size;
nvd->info_level = c->info_level;
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
20cd4: e1a08000 mov r8, r0 <== NOT EXECUTED 20cd8: e5840014 str r0, [r4, #20] <== NOT EXECUTED
if (!nvd->devices)
20cdc: 0a00004c beq 20e14 <rtems_nvdisk_initialize+0x244> <== NOT EXECUTED
return RTEMS_NO_MEMORY;
for (device = 0; device < c->device_count; device++)
20ce0: e5156008 ldr r6, [r5, #-8] <== NOT EXECUTED 20ce4: e3560000 cmp r6, #0 <== NOT EXECUTED 20ce8: 0a000022 beq 20d78 <rtems_nvdisk_initialize+0x1a8> <== NOT EXECUTED 20cec: e3a0a000 mov sl, #0 <== NOT EXECUTED 20cf0: e1a0600a mov r6, sl <== NOT EXECUTED 20cf4: e1a0700a mov r7, sl <== NOT EXECUTED 20cf8: ea000000 b 20d00 <rtems_nvdisk_initialize+0x130> <== NOT EXECUTED 20cfc: e5948014 ldr r8, [r4, #20] <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_pages_in_device (const rtems_nvdisk* nvd,
const rtems_nvdisk_device_desc* dd)
{
return dd->size / nvd->block_size;
20d00: e5159004 ldr r9, [r5, #-4] <== NOT EXECUTED
for (device = 0; device < c->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
20d04: e788700a str r7, [r8, sl] <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_pages_in_device (const rtems_nvdisk* nvd,
const rtems_nvdisk_device_desc* dd)
{
return dd->size / nvd->block_size;
20d08: e0899207 add r9, r9, r7, lsl #4 <== NOT EXECUTED 20d0c: e594100c ldr r1, [r4, #12] <== NOT EXECUTED 20d10: e5990008 ldr r0, [r9, #8] <== NOT EXECUTED 20d14: eb00e873 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
if (!nvd->devices)
return RTEMS_NO_MEMORY;
for (device = 0; device < c->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
20d18: e088800a add r8, r8, sl <== NOT EXECUTED
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
20d1c: e5880004 str r0, [r8, #4] <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_pages_in_device (const rtems_nvdisk* nvd,
const rtems_nvdisk_device_desc* dd)
{
return dd->size / nvd->block_size;
20d20: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 20d24: e1a0b000 mov fp, r0 <== NOT EXECUTED
rtems_nvdisk_page_desc_pages (const rtems_nvdisk* nvd,
const rtems_nvdisk_device_desc* dd)
{
uint32_t pages = rtems_nvdisk_pages_in_device (nvd, dd);
uint32_t bytes = pages * sizeof (uint16_t);
return ((bytes - 1) / nvd->block_size) + 1;
20d28: e1a01003 mov r1, r3 <== NOT EXECUTED 20d2c: e5990008 ldr r0, [r9, #8] <== NOT EXECUTED 20d30: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 20d34: eb00e86b bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 20d38: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 20d3c: e1a00080 lsl r0, r0, #1 <== NOT EXECUTED 20d40: e1a01003 mov r1, r3 <== NOT EXECUTED 20d44: e2400001 sub r0, r0, #1 <== NOT EXECUTED 20d48: eb00e866 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 20d4c: e2800001 add r0, r0, #1 <== NOT EXECUTED
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
dc->block_base = blocks;
20d50: e588600c str r6, [r8, #12] <== NOT EXECUTED
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
20d54: e5880008 str r0, [r8, #8] <== NOT EXECUTED
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
if (!nvd->devices)
return RTEMS_NO_MEMORY;
for (device = 0; device < c->device_count; device++)
20d58: e5153008 ldr r3, [r5, #-8] <== NOT EXECUTED 20d5c: e2877001 add r7, r7, #1 <== NOT EXECUTED
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
dc->block_base = blocks;
blocks += dc->pages - dc->pages_desc;
20d60: e060b00b rsb fp, r0, fp <== NOT EXECUTED
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
if (!nvd->devices)
return RTEMS_NO_MEMORY;
for (device = 0; device < c->device_count; device++)
20d64: e1530007 cmp r3, r7 <== NOT EXECUTED
dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
dc->block_base = blocks;
blocks += dc->pages - dc->pages_desc;
dc->descriptor = &c->devices[device];
20d68: e5889010 str r9, [r8, #16] <== NOT EXECUTED
dc->device = device;
dc->pages = rtems_nvdisk_pages_in_device (nvd, &c->devices[device]);
dc->pages_desc = rtems_nvdisk_page_desc_pages (nvd, &c->devices[device]);
dc->block_base = blocks;
blocks += dc->pages - dc->pages_desc;
20d6c: e086600b add r6, r6, fp <== NOT EXECUTED
nvd->devices = calloc (c->device_count, sizeof (rtems_nvdisk_device_ctl));
if (!nvd->devices)
return RTEMS_NO_MEMORY;
for (device = 0; device < c->device_count; device++)
20d70: e28aa014 add sl, sl, #20 <== NOT EXECUTED 20d74: 8affffe0 bhi 20cfc <rtems_nvdisk_initialize+0x12c> <== NOT EXECUTED
blocks += dc->pages - dc->pages_desc;
dc->descriptor = &c->devices[device];
}
nvd->block_count = blocks;
20d78: e5846010 str r6, [r4, #16] <== NOT EXECUTED
nvd->device_count = c->device_count;
20d7c: e5153008 ldr r3, [r5, #-8] <== NOT EXECUTED
sc = rtems_disk_create_phys(dev, c->block_size, blocks,
20d80: e59fc0d4 ldr ip, [pc, #212] ; 20e5c <rtems_nvdisk_initialize+0x28c><== NOT EXECUTED
dc->descriptor = &c->devices[device];
}
nvd->block_count = blocks;
nvd->device_count = c->device_count;
20d84: e5843018 str r3, [r4, #24] <== NOT EXECUTED
sc = rtems_disk_create_phys(dev, c->block_size, blocks,
20d88: e58dc000 str ip, [sp] <== NOT EXECUTED
20d8c: e3a0c000 mov ip, #0 <== NOT EXECUTED
20d90: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
20d94: e515200c ldr r2, [r5, #-12] <== NOT EXECUTED
20d98: e28dc028 add ip, sp, #40 ; 0x28 <== NOT EXECUTED
20d9c: e28d1020 add r1, sp, #32 <== NOT EXECUTED
20da0: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
20da4: e1a03006 mov r3, r6 <== NOT EXECUTED
20da8: e58dc008 str ip, [sp, #8] <== NOT EXECUTED
20dac: ebff97dd bl 6d28 <rtems_disk_create_phys> <== NOT EXECUTED
rtems_nvdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
20db0: e3500000 cmp r0, #0 <== NOT EXECUTED 20db4: 1a000020 bne 20e3c <rtems_nvdisk_initialize+0x26c> <== NOT EXECUTED
{
rtems_nvdisk_error ("disk create phy failed");
return sc;
}
sc = rtems_semaphore_create (rtems_build_name ('N', 'V', 'D', 'K'), 1,
20db8: e2844020 add r4, r4, #32 <== NOT EXECUTED 20dbc: e59f009c ldr r0, [pc, #156] ; 20e60 <rtems_nvdisk_initialize+0x290><== NOT EXECUTED 20dc0: e3a01001 mov r1, #1 <== NOT EXECUTED 20dc4: e3a02054 mov r2, #84 ; 0x54 <== NOT EXECUTED 20dc8: e3a03000 mov r3, #0 <== NOT EXECUTED 20dcc: e58d4000 str r4, [sp] <== NOT EXECUTED 20dd0: ebffad06 bl c1f0 <rtems_semaphore_create> <== NOT EXECUTED
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &nvd->lock);
if (sc != RTEMS_SUCCESSFUL)
20dd4: e3500000 cmp r0, #0 <== NOT EXECUTED 20dd8: 1a000013 bne 20e2c <rtems_nvdisk_initialize+0x25c> <== NOT EXECUTED
sizeof (rtems_nvdisk));
if (!rtems_nvdisks)
return RTEMS_NO_MEMORY;
for (minor = 0; minor < rtems_nvdisk_configuration_size; minor++, c++)
20ddc: e59f1068 ldr r1, [pc, #104] ; 20e4c <rtems_nvdisk_initialize+0x27c><== NOT EXECUTED
20de0: e28d3014 add r3, sp, #20 <== NOT EXECUTED
20de4: e8931008 ldm r3, {r3, ip} <== NOT EXECUTED
20de8: e5912000 ldr r2, [r1] <== NOT EXECUTED
20dec: e2833001 add r3, r3, #1 <== NOT EXECUTED
20df0: e28cc028 add ip, ip, #40 ; 0x28 <== NOT EXECUTED
20df4: e1520003 cmp r2, r3 <== NOT EXECUTED
20df8: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
20dfc: e58dc018 str ip, [sp, #24] <== NOT EXECUTED
20e00: e2855014 add r5, r5, #20 <== NOT EXECUTED
20e04: 9a000004 bls 20e1c <rtems_nvdisk_initialize+0x24c> <== NOT EXECUTED
20e08: e59f1040 ldr r1, [pc, #64] ; 20e50 <rtems_nvdisk_initialize+0x280><== NOT EXECUTED
20e0c: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED
20e10: eaffff8e b 20c50 <rtems_nvdisk_initialize+0x80> <== NOT EXECUTED
}
}
rtems_nvdisk_count = rtems_nvdisk_configuration_size;
return RTEMS_SUCCESSFUL;
20e14: e3a0601a mov r6, #26 <== NOT EXECUTED 20e18: eaffff72 b 20be8 <rtems_nvdisk_initialize+0x18> <== NOT EXECUTED
rtems_nvdisk_error ("disk lock create failed");
return sc;
}
}
rtems_nvdisk_count = rtems_nvdisk_configuration_size;
20e1c: e59f302c ldr r3, [pc, #44] ; 20e50 <rtems_nvdisk_initialize+0x280><== NOT EXECUTED 20e20: e3a06000 mov r6, #0 <== NOT EXECUTED 20e24: e5832000 str r2, [r3] <== NOT EXECUTED
return RTEMS_SUCCESSFUL;
20e28: eaffff6e b 20be8 <rtems_nvdisk_initialize+0x18> <== NOT EXECUTED 20e2c: e1a06000 mov r6, r0 <== NOT EXECUTED
sc = rtems_semaphore_create (rtems_build_name ('N', 'V', 'D', 'K'), 1,
RTEMS_PRIORITY | RTEMS_BINARY_SEMAPHORE |
RTEMS_INHERIT_PRIORITY, 0, &nvd->lock);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_nvdisk_error ("disk lock create failed");
20e30: e59f002c ldr r0, [pc, #44] ; 20e64 <rtems_nvdisk_initialize+0x294><== NOT EXECUTED 20e34: ebfffd80 bl 2043c <rtems_nvdisk_error> <== NOT EXECUTED
return sc;
20e38: eaffff6a b 20be8 <rtems_nvdisk_initialize+0x18> <== NOT EXECUTED 20e3c: e1a06000 mov r6, r0 <== NOT EXECUTED
sc = rtems_disk_create_phys(dev, c->block_size, blocks,
rtems_nvdisk_ioctl, NULL, name);
if (sc != RTEMS_SUCCESSFUL)
{
rtems_nvdisk_error ("disk create phy failed");
20e40: e59f0020 ldr r0, [pc, #32] ; 20e68 <rtems_nvdisk_initialize+0x298><== NOT EXECUTED 20e44: ebfffd7c bl 2043c <rtems_nvdisk_error> <== NOT EXECUTED
return sc;
20e48: eaffff66 b 20be8 <rtems_nvdisk_initialize+0x18> <== NOT EXECUTED
00020548 <rtems_nvdisk_ioctl>:
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_nvdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
{
20548: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
dev_t dev = rtems_disk_get_device_identifier (dd);
rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
rtems_blkdev_request* r = argp;
rtems_status_code sc;
if (minor >= rtems_nvdisk_count)
2054c: e59fc600 ldr ip, [pc, #1536] ; 20b54 <rtems_nvdisk_ioctl+0x60c><== NOT EXECUTED
dev_t device
)
{
union __rtems_dev_t temp;
temp.device = device;
20550: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_nvdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
{
20554: e1a05000 mov r5, r0 <== NOT EXECUTED
dev_t dev = rtems_disk_get_device_identifier (dd);
rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
rtems_blkdev_request* r = argp;
rtems_status_code sc;
if (minor >= rtems_nvdisk_count)
20558: e59c0000 ldr r0, [ip] <== NOT EXECUTED
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_nvdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
{
2055c: e24dd020 sub sp, sp, #32 <== NOT EXECUTED
dev_t dev = rtems_disk_get_device_identifier (dd);
rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
rtems_blkdev_request* r = argp;
rtems_status_code sc;
if (minor >= rtems_nvdisk_count)
20560: e1500003 cmp r0, r3 <== NOT EXECUTED
* @param argp IOCTL argument.
* @retval The IOCTL return value
*/
static int
rtems_nvdisk_ioctl (rtems_disk_device *dd, uint32_t req, void* argp)
{
20564: e1a04001 mov r4, r1 <== NOT EXECUTED 20568: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
dev_t dev = rtems_disk_get_device_identifier (dd);
rtems_device_minor_number minor = rtems_filesystem_dev_minor_t (dev);
rtems_blkdev_request* r = argp;
rtems_status_code sc;
if (minor >= rtems_nvdisk_count)
2056c: 9a0000fd bls 20968 <rtems_nvdisk_ioctl+0x420> <== NOT EXECUTED
{
errno = ENODEV;
return -1;
}
if (rtems_nvdisks[minor].device_count == 0)
20570: e59fe5dc ldr lr, [pc, #1500] ; 20b54 <rtems_nvdisk_ioctl+0x60c><== NOT EXECUTED 20574: e0833103 add r3, r3, r3, lsl #2 <== NOT EXECUTED 20578: e59e2004 ldr r2, [lr, #4] <== NOT EXECUTED 2057c: e1a03183 lsl r3, r3, #3 <== NOT EXECUTED 20580: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 20584: e0823003 add r3, r2, r3 <== NOT EXECUTED 20588: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED 2058c: e3530000 cmp r3, #0 <== NOT EXECUTED 20590: 0a0000f4 beq 20968 <rtems_nvdisk_ioctl+0x420> <== NOT EXECUTED
{
errno = ENODEV;
return -1;
}
errno = 0;
20594: eb008a95 bl 42ff0 <__errno> <== NOT EXECUTED
sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
20598: e59f15b4 ldr r1, [pc, #1460] ; 20b54 <rtems_nvdisk_ioctl+0x60c><== NOT EXECUTED 2059c: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED 205a0: e5912004 ldr r2, [r1, #4] <== NOT EXECUTED
{
errno = ENODEV;
return -1;
}
errno = 0;
205a4: e3a03000 mov r3, #0 <== NOT EXECUTED
sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
205a8: e082200c add r2, r2, ip <== NOT EXECUTED
{
errno = ENODEV;
return -1;
}
errno = 0;
205ac: e5803000 str r3, [r0] <== NOT EXECUTED
sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
205b0: e1a01003 mov r1, r3 <== NOT EXECUTED 205b4: e5920020 ldr r0, [r2, #32] <== NOT EXECUTED 205b8: e1a02003 mov r2, r3 <== NOT EXECUTED 205bc: ebffafc0 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
205c0: e250a000 subs sl, r0, #0 <== NOT EXECUTED 205c4: 0a000009 beq 205f0 <rtems_nvdisk_ioctl+0xa8> <== NOT EXECUTED
break;
}
sc = rtems_semaphore_release (rtems_nvdisks[minor].lock);
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
205c8: eb008a88 bl 42ff0 <__errno> <== NOT EXECUTED 205cc: e3a03005 mov r3, #5 <== NOT EXECUTED 205d0: e5803000 str r3, [r0] <== NOT EXECUTED
}
return errno == 0 ? 0 : -1;
205d4: eb008a85 bl 42ff0 <__errno> <== NOT EXECUTED 205d8: e5903000 ldr r3, [r0] <== NOT EXECUTED 205dc: e3530000 cmp r3, #0 <== NOT EXECUTED 205e0: 01a00003 moveq r0, r3 <== NOT EXECUTED 205e4: 13e00000 mvnne r0, #0 <== NOT EXECUTED
}
205e8: e28dd020 add sp, sp, #32 <== NOT EXECUTED
205ec: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
else
{
errno = 0;
205f0: eb008a7e bl 42ff0 <__errno> <== NOT EXECUTED
switch (req)
205f4: e3a03202 mov r3, #536870912 ; 0x20000000 <== NOT EXECUTED 205f8: e2833c42 add r3, r3, #16896 ; 0x4200 <== NOT EXECUTED 205fc: e2833082 add r3, r3, #130 ; 0x82 <== NOT EXECUTED 20600: e1540003 cmp r4, r3 <== NOT EXECUTED
sc = rtems_semaphore_obtain (rtems_nvdisks[minor].lock, RTEMS_WAIT, 0);
if (sc != RTEMS_SUCCESSFUL)
errno = EIO;
else
{
errno = 0;
20604: e580a000 str sl, [r0] <== NOT EXECUTED
switch (req)
20608: 0a000043 beq 2071c <rtems_nvdisk_ioctl+0x1d4> <== NOT EXECUTED 2060c: e3a03961 mov r3, #1589248 ; 0x184000 <== NOT EXECUTED 20610: e2833c02 add r3, r3, #512 ; 0x200 <== NOT EXECUTED 20614: e2833107 add r3, r3, #-1073741823 ; 0xc0000001 <== NOT EXECUTED 20618: e1540003 cmp r4, r3 <== NOT EXECUTED 2061c: 0a000045 beq 20738 <rtems_nvdisk_ioctl+0x1f0> <== NOT EXECUTED 20620: e3a03202 mov r3, #536870912 ; 0x20000000 <== NOT EXECUTED 20624: e2833c42 add r3, r3, #16896 ; 0x4200 <== NOT EXECUTED 20628: e2833080 add r3, r3, #128 ; 0x80 <== NOT EXECUTED 2062c: e1540003 cmp r4, r3 <== NOT EXECUTED 20630: 0a00000c beq 20668 <rtems_nvdisk_ioctl+0x120> <== NOT EXECUTED
case RTEMS_NVDISK_IOCTL_INFO_LEVEL:
rtems_nvdisks[minor].info_level = (uintptr_t) argp;
break;
default:
rtems_blkdev_ioctl (dd, req, argp);
20634: e1a01004 mov r1, r4 <== NOT EXECUTED 20638: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 2063c: e1a00005 mov r0, r5 <== NOT EXECUTED 20640: ebff956f bl 5c04 <rtems_blkdev_ioctl> <== NOT EXECUTED 20644: e59f1508 ldr r1, [pc, #1288] ; 20b54 <rtems_nvdisk_ioctl+0x60c><== NOT EXECUTED 20648: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 2064c: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 20650: e0833002 add r3, r3, r2 <== NOT EXECUTED
break;
}
sc = rtems_semaphore_release (rtems_nvdisks[minor].lock);
20654: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 20658: ebffafe1 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
2065c: e3500000 cmp r0, #0 <== NOT EXECUTED 20660: 0affffdb beq 205d4 <rtems_nvdisk_ioctl+0x8c> <== NOT EXECUTED 20664: eaffffd7 b 205c8 <rtems_nvdisk_ioctl+0x80> <== NOT EXECUTED
break;
}
break;
case RTEMS_NVDISK_IOCTL_ERASE_DISK:
errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]);
20668: eb008a60 bl 42ff0 <__errno> <== NOT EXECUTED 2066c: e59f34e0 ldr r3, [pc, #1248] ; 20b54 <rtems_nvdisk_ioctl+0x60c><== NOT EXECUTED 20670: e59dc008 ldr ip, [sp, #8] <== NOT EXECUTED 20674: e5936004 ldr r6, [r3, #4] <== NOT EXECUTED 20678: e086600c add r6, r6, ip <== NOT EXECUTED 2067c: e1a0b000 mov fp, r0 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "erase-disk");
#endif
for (device = 0; device < nvd->device_count; device++)
20680: e5960018 ldr r0, [r6, #24] <== NOT EXECUTED 20684: e3500000 cmp r0, #0 <== NOT EXECUTED 20688: 0a0000aa beq 20938 <rtems_nvdisk_ioctl+0x3f0> <== NOT EXECUTED 2068c: e1a0900a mov r9, sl <== NOT EXECUTED 20690: e28d701e add r7, sp, #30 <== NOT EXECUTED
ops = nvd->devices[device].descriptor->nv_ops;
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_printf (nvd, " dev-write: %02d-%08x: s=%d",
device, offset, size);
#endif
return ops->write (device, dd->flags, dd->base, offset, buffer, size);
20694: e3a08002 mov r8, #2 <== NOT EXECUTED
rtems_nvdisk_info (nvd, "erase-disk");
#endif
for (device = 0; device < nvd->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
20698: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 2069c: e083400a add r4, r3, sl <== NOT EXECUTED
uint32_t page;
for (page = 0; page < (dc->pages - dc->pages_desc); page++)
206a0: e9940006 ldmib r4, {r1, r2} <== NOT EXECUTED
206a4: e1510002 cmp r1, r2 <== NOT EXECUTED
206a8: 0a00009e beq 20928 <rtems_nvdisk_ioctl+0x3e0> <== NOT EXECUTED
206ac: e3a05000 mov r5, #0 <== NOT EXECUTED
206b0: ea000004 b 206c8 <rtems_nvdisk_ioctl+0x180> <== NOT EXECUTED
206b4: e9940009 ldmib r4, {r0, r3} <== NOT EXECUTED
206b8: e0403003 sub r3, r0, r3 <== NOT EXECUTED
206bc: e1550003 cmp r5, r3 <== NOT EXECUTED
206c0: 2a000097 bcs 20924 <rtems_nvdisk_ioctl+0x3dc> <== NOT EXECUTED
206c4: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED
{
int ret = rtems_nvdisk_write_checksum (nvd, dc->device, page, 0xffff);
206c8: e5940000 ldr r0, [r4] <== NOT EXECUTED
* Get the descriptor for a device.
*/
static const rtems_nvdisk_device_desc*
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{
return nvd->devices[device].descriptor;
206cc: e0802100 add r2, r0, r0, lsl #2 <== NOT EXECUTED 206d0: e0833102 add r3, r3, r2, lsl #2 <== NOT EXECUTED 206d4: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
uint32_t page;
for (page = 0; page < (dc->pages - dc->pages_desc); page++)
{
int ret = rtems_nvdisk_write_checksum (nvd, dc->device, page, 0xffff);
206d8: e3e0e000 mvn lr, #0 <== NOT EXECUTED
ops = nvd->devices[device].descriptor->nv_ops;
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_printf (nvd, " dev-write: %02d-%08x: s=%d",
device, offset, size);
#endif
return ops->write (device, dd->flags, dd->base, offset, buffer, size);
206dc: e8930006 ldm r3, {r1, r2} <== NOT EXECUTED
206e0: e593c00c ldr ip, [r3, #12] <== NOT EXECUTED
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
uint32_t page;
for (page = 0; page < (dc->pages - dc->pages_desc); page++)
{
int ret = rtems_nvdisk_write_checksum (nvd, dc->device, page, 0xffff);
206e4: e1cde1be strh lr, [sp, #30] <== NOT EXECUTED
ops = nvd->devices[device].descriptor->nv_ops;
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_printf (nvd, " dev-write: %02d-%08x: s=%d",
device, offset, size);
#endif
return ops->write (device, dd->flags, dd->base, offset, buffer, size);
206e8: e1a03085 lsl r3, r5, #1 <== NOT EXECUTED
206ec: e88d0180 stm sp, {r7, r8} <== NOT EXECUTED
206f0: e1a0e00f mov lr, pc <== NOT EXECUTED
206f4: e59cf004 ldr pc, [ip, #4] <== NOT EXECUTED
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
uint32_t page;
for (page = 0; page < (dc->pages - dc->pages_desc); page++)
{
int ret = rtems_nvdisk_write_checksum (nvd, dc->device, page, 0xffff);
if (ret)
206f8: e3500000 cmp r0, #0 <== NOT EXECUTED
for (device = 0; device < nvd->device_count; device++)
{
rtems_nvdisk_device_ctl* dc = &nvd->devices[device];
uint32_t page;
for (page = 0; page < (dc->pages - dc->pages_desc); page++)
206fc: e2855001 add r5, r5, #1 <== NOT EXECUTED
{
int ret = rtems_nvdisk_write_checksum (nvd, dc->device, page, 0xffff);
if (ret)
20700: 0affffeb beq 206b4 <rtems_nvdisk_ioctl+0x16c> <== NOT EXECUTED
break;
}
break;
case RTEMS_NVDISK_IOCTL_ERASE_DISK:
errno = rtems_nvdisk_erase_disk (&rtems_nvdisks[minor]);
20704: e59f1448 ldr r1, [pc, #1096] ; 20b54 <rtems_nvdisk_ioctl+0x60c><== NOT EXECUTED 20708: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 2070c: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 20710: e58b0000 str r0, [fp] <== NOT EXECUTED 20714: e0833002 add r3, r3, r2 <== NOT EXECUTED
break;
20718: eaffffcd b 20654 <rtems_nvdisk_ioctl+0x10c> <== NOT EXECUTED
case RTEMS_NVDISK_IOCTL_INFO_LEVEL:
rtems_nvdisks[minor].info_level = (uintptr_t) argp;
2071c: e59fc430 ldr ip, [pc, #1072] ; 20b54 <rtems_nvdisk_ioctl+0x60c><== NOT EXECUTED 20720: e59de008 ldr lr, [sp, #8] <== NOT EXECUTED 20724: e59c3004 ldr r3, [ip, #4] <== NOT EXECUTED 20728: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED 2072c: e083300e add r3, r3, lr <== NOT EXECUTED 20730: e5830024 str r0, [r3, #36] ; 0x24 <== NOT EXECUTED
break;
20734: eaffffc6 b 20654 <rtems_nvdisk_ioctl+0x10c> <== NOT EXECUTED
{
errno = 0;
switch (req)
{
case RTEMS_BLKIO_REQUEST:
switch (r->req)
20738: e59de010 ldr lr, [sp, #16] <== NOT EXECUTED 2073c: e59e4000 ldr r4, [lr] <== NOT EXECUTED 20740: e3540000 cmp r4, #0 <== NOT EXECUTED 20744: 1a00007d bne 20940 <rtems_nvdisk_ioctl+0x3f8> <== NOT EXECUTED
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
20748: eb008a28 bl 42ff0 <__errno> <== NOT EXECUTED 2074c: e58d0018 str r0, [sp, #24] <== NOT EXECUTED 20750: e59f03fc ldr r0, [pc, #1020] ; 20b54 <rtems_nvdisk_ioctl+0x60c><== NOT EXECUTED 20754: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 20758: e5906004 ldr r6, [r0, #4] <== NOT EXECUTED
ret = rtems_nvdisk_read_checksum (nvd, dc->device, page, &crc);
if (ret)
return ret;
if (crc == 0xffff)
2075c: e3a03801 mov r3, #65536 ; 0x10000 <== NOT EXECUTED
{
case RTEMS_BLKIO_REQUEST:
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
20760: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 20764: e3a0c001 mov ip, #1 <== NOT EXECUTED
ret = rtems_nvdisk_read_checksum (nvd, dc->device, page, &crc);
if (ret)
return ret;
if (crc == 0xffff)
20768: e2433001 sub r3, r3, #1 <== NOT EXECUTED
{
case RTEMS_BLKIO_REQUEST:
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
2076c: e5924010 ldr r4, [r2, #16] <== NOT EXECUTED 20770: e58dc014 str ip, [sp, #20] <== NOT EXECUTED 20774: e0866001 add r6, r6, r1 <== NOT EXECUTED 20778: e2828028 add r8, r2, #40 ; 0x28 <== NOT EXECUTED 2077c: e1a0b003 mov fp, r3 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "read: blocks=%d", req->bufnum);
#endif
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
20780: e59d0014 ldr r0, [sp, #20] <== NOT EXECUTED 20784: e2403001 sub r3, r0, #1 <== NOT EXECUTED 20788: e1530004 cmp r3, r4 <== NOT EXECUTED 2078c: 2a0000eb bcs 20b40 <rtems_nvdisk_ioctl+0x5f8> <== NOT EXECUTED
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
20790: e518000c ldr r0, [r8, #-12] <== NOT EXECUTED 20794: e596100c ldr r1, [r6, #12] <== NOT EXECUTED 20798: eb00e9d2 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
2079c: e3500000 cmp r0, #0 <== NOT EXECUTED 207a0: e58d000c str r0, [sp, #12] <== NOT EXECUTED
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
207a4: e5185008 ldr r5, [r8, #-8] <== NOT EXECUTED
for (b = 0; b < nvb; b++, data += nvd->block_size)
207a8: 0a000075 beq 20984 <rtems_nvdisk_ioctl+0x43c> <== NOT EXECUTED
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
207ac: e3a09000 mov r9, #0 <== NOT EXECUTED
for (b = 0; b < nvb; b++, data += nvd->block_size)
{
ret = rtems_nvdisk_read_block (nvd, sg->block + b, data);
207b0: e5187010 ldr r7, [r8, #-16] <== NOT EXECUTED 207b4: e0897007 add r7, r9, r7 <== NOT EXECUTED
uint32_t page;
uint16_t crc;
uint16_t cs;
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
207b8: e1a00006 mov r0, r6 <== NOT EXECUTED 207bc: e1a01007 mov r1, r7 <== NOT EXECUTED 207c0: ebffff3d bl 204bc <rtems_nvdisk_get_device> <== NOT EXECUTED
if (!dc)
207c4: e2504000 subs r4, r0, #0 <== NOT EXECUTED 207c8: 0a00003b beq 208bc <rtems_nvdisk_ioctl+0x374> <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, " read-block:%d=>%02d-%03d, cs:%04x",
block, dc->device, page, crc);
#endif
ret = rtems_nvdisk_read_checksum (nvd, dc->device, page, &crc);
207cc: e5940000 ldr r0, [r4] <== NOT EXECUTED
* Get the descriptor for a device.
*/
static const rtems_nvdisk_device_desc*
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{
return nvd->devices[device].descriptor;
207d0: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 207d4: e0802100 add r2, r0, r0, lsl #2 <== NOT EXECUTED 207d8: e0833102 add r3, r3, r2, lsl #2 <== NOT EXECUTED 207dc: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
207e0: e594a00c ldr sl, [r4, #12] <== NOT EXECUTED
ops = nvd->devices[device].descriptor->nv_ops;
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_printf (nvd, " dev-read: %02d-%08x: s=%d",
device, offset, size);
#endif
return ops->read (device, dd->flags, dd->base, offset, buffer, size);
207e4: e8930006 ldm r3, {r1, r2} <== NOT EXECUTED
207e8: e593c00c ldr ip, [r3, #12] <== NOT EXECUTED
207ec: e28de01e add lr, sp, #30 <== NOT EXECUTED
207f0: e3a03002 mov r3, #2 <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
207f4: e06aa007 rsb sl, sl, r7 <== NOT EXECUTED
ops = nvd->devices[device].descriptor->nv_ops;
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_printf (nvd, " dev-read: %02d-%08x: s=%d",
device, offset, size);
#endif
return ops->read (device, dd->flags, dd->base, offset, buffer, size);
207f8: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 207fc: e58de000 str lr, [sp] <== NOT EXECUTED 20800: e1a0308a lsl r3, sl, #1 <== NOT EXECUTED 20804: e1a0e00f mov lr, pc <== NOT EXECUTED 20808: e59cf000 ldr pc, [ip] <== NOT EXECUTED
block, dc->device, page, crc);
#endif
ret = rtems_nvdisk_read_checksum (nvd, dc->device, page, &crc);
if (ret)
2080c: e2501000 subs r1, r0, #0 <== NOT EXECUTED 20810: 1a000037 bne 208f4 <rtems_nvdisk_ioctl+0x3ac> <== NOT EXECUTED
return ret;
if (crc == 0xffff)
20814: e1dd31be ldrh r3, [sp, #30] <== NOT EXECUTED 20818: e153000b cmp r3, fp <== NOT EXECUTED 2081c: 0a000036 beq 208fc <rtems_nvdisk_ioctl+0x3b4> <== NOT EXECUTED
#endif
memset (buffer, 0, nvd->block_size);
return 0;
}
ret = rtems_nvdisk_read_page (nvd, dc->device, page + dc->pages_desc, buffer);
20820: e5940000 ldr r0, [r4] <== NOT EXECUTED
* Get the descriptor for a device.
*/
static const rtems_nvdisk_device_desc*
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{
return nvd->devices[device].descriptor;
20824: e5963014 ldr r3, [r6, #20] <== NOT EXECUTED 20828: e0802100 add r2, r0, r0, lsl #2 <== NOT EXECUTED 2082c: e0833102 add r3, r3, r2, lsl #2 <== NOT EXECUTED 20830: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED
ops = nvd->devices[device].descriptor->nv_ops;
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_printf (nvd, " dev-read: %02d-%08x: s=%d",
device, offset, size);
#endif
return ops->read (device, dd->flags, dd->base, offset, buffer, size);
20834: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
rtems_nvdisk_read_page (const rtems_nvdisk* nvd,
uint32_t device,
uint32_t page,
void* buffer)
{
return rtems_nvdisk_device_read (nvd, device,
20838: e596e00c ldr lr, [r6, #12] <== NOT EXECUTED
ops = nvd->devices[device].descriptor->nv_ops;
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_printf (nvd, " dev-read: %02d-%08x: s=%d",
device, offset, size);
#endif
return ops->read (device, dd->flags, dd->base, offset, buffer, size);
2083c: e08a3003 add r3, sl, r3 <== NOT EXECUTED
20840: e89c0006 ldm ip, {r1, r2} <== NOT EXECUTED
20844: e003039e mul r3, lr, r3 <== NOT EXECUTED
20848: e59cc00c ldr ip, [ip, #12] <== NOT EXECUTED
2084c: e88d4020 stm sp, {r5, lr} <== NOT EXECUTED
20850: e1a0e00f mov lr, pc <== NOT EXECUTED
20854: e59cf000 ldr pc, [ip] <== NOT EXECUTED
return 0;
}
ret = rtems_nvdisk_read_page (nvd, dc->device, page + dc->pages_desc, buffer);
if (ret)
20858: e2501000 subs r1, r0, #0 <== NOT EXECUTED 2085c: 1a000024 bne 208f4 <rtems_nvdisk_ioctl+0x3ac> <== NOT EXECUTED
return ret;
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
20860: e596c00c ldr ip, [r6, #12] <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
20864: e35c0000 cmp ip, #0 <== NOT EXECUTED 20868: 03a02801 moveq r2, #65536 ; 0x10000 <== NOT EXECUTED 2086c: 02422001 subeq r2, r2, #1 <== NOT EXECUTED 20870: 0a00000b beq 208a4 <rtems_nvdisk_ioctl+0x35c> <== NOT EXECUTED 20874: e59fe2d8 ldr lr, [pc, #728] ; 20b54 <rtems_nvdisk_ioctl+0x60c><== NOT EXECUTED 20878: e3a02801 mov r2, #65536 ; 0x10000 <== NOT EXECUTED 2087c: e59e3008 ldr r3, [lr, #8] <== NOT EXECUTED 20880: e2422001 sub r2, r2, #1 <== NOT EXECUTED
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
20884: e7d50001 ldrb r0, [r5, r1] <== NOT EXECUTED 20888: e0222000 eor r2, r2, r0 <== NOT EXECUTED 2088c: e20220ff and r2, r2, #255 ; 0xff <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
20890: e2811001 add r1, r1, #1 <== NOT EXECUTED
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
20894: e1a02082 lsl r2, r2, #1 <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
20898: e15c0001 cmp ip, r1 <== NOT EXECUTED
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
2089c: e19320b2 ldrh r2, [r3, r2] <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
208a0: 8afffff7 bhi 20884 <rtems_nvdisk_ioctl+0x33c> <== NOT EXECUTED
if (ret)
return ret;
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
if (cs != crc)
208a4: e1dd31be ldrh r3, [sp, #30] <== NOT EXECUTED 208a8: e1520003 cmp r2, r3 <== NOT EXECUTED 208ac: 0a000016 beq 2090c <rtems_nvdisk_ioctl+0x3c4> <== NOT EXECUTED
{
rtems_nvdisk_error ("read-block: crc failure: %d: buffer:%04x page:%04x",
208b0: e1a01007 mov r1, r7 <== NOT EXECUTED 208b4: e59f029c ldr r0, [pc, #668] ; 20b58 <rtems_nvdisk_ioctl+0x610><== NOT EXECUTED 208b8: ebfffedf bl 2043c <rtems_nvdisk_error> <== NOT EXECUTED 208bc: e3a0b005 mov fp, #5 <== NOT EXECUTED 208c0: e3a0101b mov r1, #27 <== NOT EXECUTED
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
208c4: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
208c8: e5920008 ldr r0, [r2, #8] <== NOT EXECUTED
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
208cc: e582100c str r1, [r2, #12] <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
208d0: e1a0e00f mov lr, pc <== NOT EXECUTED 208d4: e592f004 ldr pc, [r2, #4] <== NOT EXECUTED
{
case RTEMS_BLKIO_REQUEST:
switch (r->req)
{
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
208d8: e59fc274 ldr ip, [pc, #628] ; 20b54 <rtems_nvdisk_ioctl+0x60c><== NOT EXECUTED 208dc: e59de018 ldr lr, [sp, #24] <== NOT EXECUTED 208e0: e59c3004 ldr r3, [ip, #4] <== NOT EXECUTED 208e4: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 208e8: e58eb000 str fp, [lr] <== NOT EXECUTED 208ec: e0833000 add r3, r3, r0 <== NOT EXECUTED
break;
208f0: eaffff57 b 20654 <rtems_nvdisk_ioctl+0x10c> <== NOT EXECUTED 208f4: e1a0b001 mov fp, r1 <== NOT EXECUTED 208f8: eafffff0 b 208c0 <rtems_nvdisk_ioctl+0x378> <== NOT EXECUTED
if (crc == 0xffff)
{
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_warning (nvd, "read-block: crc not set: %d", block);
#endif
memset (buffer, 0, nvd->block_size);
208fc: e1a00005 mov r0, r5 <== NOT EXECUTED 20900: e596200c ldr r2, [r6, #12] <== NOT EXECUTED 20904: eb0096f0 bl 464cc <memset> <== NOT EXECUTED 20908: e596c00c ldr ip, [r6, #12] <== NOT EXECUTED
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
2090c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 20910: e2899001 add r9, r9, #1 <== NOT EXECUTED 20914: e1530009 cmp r3, r9 <== NOT EXECUTED 20918: 9a000017 bls 2097c <rtems_nvdisk_ioctl+0x434> <== NOT EXECUTED 2091c: e085500c add r5, r5, ip <== NOT EXECUTED 20920: eaffffa2 b 207b0 <rtems_nvdisk_ioctl+0x268> <== NOT EXECUTED 20924: e5960018 ldr r0, [r6, #24] <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "erase-disk");
#endif
for (device = 0; device < nvd->device_count; device++)
20928: e2899001 add r9, r9, #1 <== NOT EXECUTED 2092c: e1590000 cmp r9, r0 <== NOT EXECUTED 20930: e28aa014 add sl, sl, #20 <== NOT EXECUTED 20934: 3affff57 bcc 20698 <rtems_nvdisk_ioctl+0x150> <== NOT EXECUTED 20938: e3a00000 mov r0, #0 <== NOT EXECUTED 2093c: eaffff70 b 20704 <rtems_nvdisk_ioctl+0x1bc> <== NOT EXECUTED
{
errno = 0;
switch (req)
{
case RTEMS_BLKIO_REQUEST:
switch (r->req)
20940: e3540001 cmp r4, #1 <== NOT EXECUTED 20944: 0a000013 beq 20998 <rtems_nvdisk_ioctl+0x450> <== NOT EXECUTED
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_nvdisk_write (&rtems_nvdisks[minor], r);
break;
default:
errno = EINVAL;
20948: eb0089a8 bl 42ff0 <__errno> <== NOT EXECUTED 2094c: e59f1200 ldr r1, [pc, #512] ; 20b54 <rtems_nvdisk_ioctl+0x60c><== NOT EXECUTED 20950: e3a02016 mov r2, #22 <== NOT EXECUTED 20954: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 20958: e5802000 str r2, [r0] <== NOT EXECUTED 2095c: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 20960: e0833002 add r3, r3, r2 <== NOT EXECUTED 20964: eaffff3a b 20654 <rtems_nvdisk_ioctl+0x10c> <== NOT EXECUTED
return -1;
}
if (rtems_nvdisks[minor].device_count == 0)
{
errno = ENODEV;
20968: eb0089a0 bl 42ff0 <__errno> <== NOT EXECUTED 2096c: e3a03013 mov r3, #19 <== NOT EXECUTED 20970: e5803000 str r3, [r0] <== NOT EXECUTED 20974: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
20978: eaffff1a b 205e8 <rtems_nvdisk_ioctl+0xa0> <== NOT EXECUTED
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
2097c: e59dc010 ldr ip, [sp, #16] <== NOT EXECUTED 20980: e59c4010 ldr r4, [ip, #16] <== NOT EXECUTED 20984: e59de014 ldr lr, [sp, #20] <== NOT EXECUTED 20988: e28ee001 add lr, lr, #1 <== NOT EXECUTED 2098c: e2888010 add r8, r8, #16 <== NOT EXECUTED 20990: e58de014 str lr, [sp, #20] <== NOT EXECUTED 20994: eaffff79 b 20780 <rtems_nvdisk_ioctl+0x238> <== NOT EXECUTED
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
break;
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_nvdisk_write (&rtems_nvdisks[minor], r);
20998: eb008994 bl 42ff0 <__errno> <== NOT EXECUTED 2099c: e59f11b0 ldr r1, [pc, #432] ; 20b54 <rtems_nvdisk_ioctl+0x60c><== NOT EXECUTED 209a0: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 209a4: e5917004 ldr r7, [r1, #4] <== NOT EXECUTED 209a8: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 209ac: e58d400c str r4, [sp, #12] <== NOT EXECUTED 209b0: e58d0014 str r0, [sp, #20] <== NOT EXECUTED 209b4: e5934010 ldr r4, [r3, #16] <== NOT EXECUTED 209b8: e0877002 add r7, r7, r2 <== NOT EXECUTED 209bc: e283a028 add sl, r3, #40 ; 0x28 <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "write: blocks=%d", req->bufnum);
#endif
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
209c0: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 209c4: e2413001 sub r3, r1, #1 <== NOT EXECUTED 209c8: e1540003 cmp r4, r3 <== NOT EXECUTED 209cc: 9a00005e bls 20b4c <rtems_nvdisk_ioctl+0x604> <== NOT EXECUTED
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
209d0: e51a000c ldr r0, [sl, #-12] <== NOT EXECUTED 209d4: e597100c ldr r1, [r7, #12] <== NOT EXECUTED 209d8: eb00e942 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
209dc: e250b000 subs fp, r0, #0 <== NOT EXECUTED
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
209e0: e51a5008 ldr r5, [sl, #-8] <== NOT EXECUTED
for (b = 0; b < nvb; b++, data += nvd->block_size)
209e4: 0a000050 beq 20b2c <rtems_nvdisk_ioctl+0x5e4> <== NOT EXECUTED
{
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
209e8: e3a08000 mov r8, #0 <== NOT EXECUTED
for (b = 0; b < nvb; b++, data += nvd->block_size)
{
ret = rtems_nvdisk_write_block (nvd, sg->block + b, data);
209ec: e51a9010 ldr r9, [sl, #-16] <== NOT EXECUTED 209f0: e0889009 add r9, r8, r9 <== NOT EXECUTED
rtems_nvdisk_device_ctl* dc;
uint32_t page;
uint16_t cs;
int ret;
dc = rtems_nvdisk_get_device (nvd, block);
209f4: e1a00007 mov r0, r7 <== NOT EXECUTED 209f8: e1a01009 mov r1, r9 <== NOT EXECUTED 209fc: ebfffeae bl 204bc <rtems_nvdisk_get_device> <== NOT EXECUTED
if (!dc)
20a00: e2506000 subs r6, r0, #0 <== NOT EXECUTED 20a04: 0a000022 beq 20a94 <rtems_nvdisk_ioctl+0x54c> <== NOT EXECUTED
return EIO;
page = rtems_nvdisk_get_page (dc, block);
cs = rtems_nvdisk_page_checksum (buffer, nvd->block_size);
20a08: e597e00c ldr lr, [r7, #12] <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
20a0c: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
20a10: e35e0000 cmp lr, #0 <== NOT EXECUTED 20a14: 03a04801 moveq r4, #65536 ; 0x10000 <== NOT EXECUTED
*/
static uint32_t
rtems_nvdisk_get_page (rtems_nvdisk_device_ctl* dc,
uint32_t block)
{
return block - dc->block_base;
20a18: e0639009 rsb r9, r3, r9 <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
20a1c: 02444001 subeq r4, r4, #1 <== NOT EXECUTED 20a20: 0a00000c beq 20a58 <rtems_nvdisk_ioctl+0x510> <== NOT EXECUTED 20a24: e59fc128 ldr ip, [pc, #296] ; 20b54 <rtems_nvdisk_ioctl+0x60c><== NOT EXECUTED 20a28: e3a04801 mov r4, #65536 ; 0x10000 <== NOT EXECUTED 20a2c: e59c1008 ldr r1, [ip, #8] <== NOT EXECUTED 20a30: e2444001 sub r4, r4, #1 <== NOT EXECUTED 20a34: e3a03000 mov r3, #0 <== NOT EXECUTED
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
20a38: e7d52003 ldrb r2, [r5, r3] <== NOT EXECUTED 20a3c: e0242002 eor r2, r4, r2 <== NOT EXECUTED 20a40: e20220ff and r2, r2, #255 ; 0xff <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
20a44: e2833001 add r3, r3, #1 <== NOT EXECUTED
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
20a48: e1a02082 lsl r2, r2, #1 <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
20a4c: e15e0003 cmp lr, r3 <== NOT EXECUTED
cs = rtems_nvdisk_calc_crc16 (cs, *buffer);
20a50: e19140b2 ldrh r4, [r1, r2] <== NOT EXECUTED
rtems_nvdisk_page_checksum (const uint8_t* buffer, uint32_t page_size)
{
uint16_t cs = 0xffff;
uint32_t i;
for (i = 0; i < page_size; i++, buffer++)
20a54: 8afffff7 bhi 20a38 <rtems_nvdisk_ioctl+0x4f0> <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, " write-block:%d=>%02d-%03d", block, dc->device, page);
#endif
ret = rtems_nvdisk_write_page (nvd, dc->device, page + dc->pages_desc, buffer);
20a58: e5960000 ldr r0, [r6] <== NOT EXECUTED
* Get the descriptor for a device.
*/
static const rtems_nvdisk_device_desc*
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{
return nvd->devices[device].descriptor;
20a5c: e5973014 ldr r3, [r7, #20] <== NOT EXECUTED 20a60: e0802100 add r2, r0, r0, lsl #2 <== NOT EXECUTED 20a64: e0833102 add r3, r3, r2, lsl #2 <== NOT EXECUTED 20a68: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED
ops = nvd->devices[device].descriptor->nv_ops;
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_printf (nvd, " dev-write: %02d-%08x: s=%d",
device, offset, size);
#endif
return ops->write (device, dd->flags, dd->base, offset, buffer, size);
20a6c: e5963008 ldr r3, [r6, #8] <== NOT EXECUTED
20a70: e0893003 add r3, r9, r3 <== NOT EXECUTED
20a74: e89c0006 ldm ip, {r1, r2} <== NOT EXECUTED
20a78: e003039e mul r3, lr, r3 <== NOT EXECUTED
20a7c: e59cc00c ldr ip, [ip, #12] <== NOT EXECUTED
20a80: e88d4020 stm sp, {r5, lr} <== NOT EXECUTED
20a84: e1a0e00f mov lr, pc <== NOT EXECUTED
20a88: e59cf004 ldr pc, [ip, #4] <== NOT EXECUTED
rtems_nvdisk_info (nvd, " write-block:%d=>%02d-%03d", block, dc->device, page);
#endif
ret = rtems_nvdisk_write_page (nvd, dc->device, page + dc->pages_desc, buffer);
if (ret)
20a8c: e3500000 cmp r0, #0 <== NOT EXECUTED 20a90: 0a00000d beq 20acc <rtems_nvdisk_ioctl+0x584> <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "write: blocks=%d", req->bufnum);
#endif
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
20a94: e3a0101b mov r1, #27 <== NOT EXECUTED
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
20a98: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
20a9c: e5920008 ldr r0, [r2, #8] <== NOT EXECUTED
if (ret)
break;
}
}
req->status = ret ? RTEMS_IO_ERROR : RTEMS_SUCCESSFUL;
20aa0: e582100c str r1, [r2, #12] <== NOT EXECUTED
req->req_done (req->done_arg, req->status);
20aa4: e1a0e00f mov lr, pc <== NOT EXECUTED 20aa8: e592f004 ldr pc, [r2, #4] <== NOT EXECUTED
case RTEMS_BLKDEV_REQ_READ:
errno = rtems_nvdisk_read (&rtems_nvdisks[minor], r);
break;
case RTEMS_BLKDEV_REQ_WRITE:
errno = rtems_nvdisk_write (&rtems_nvdisks[minor], r);
20aac: e59fc0a0 ldr ip, [pc, #160] ; 20b54 <rtems_nvdisk_ioctl+0x60c><== NOT EXECUTED 20ab0: e59de014 ldr lr, [sp, #20] <== NOT EXECUTED 20ab4: e59c3004 ldr r3, [ip, #4] <== NOT EXECUTED 20ab8: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 20abc: e3a02000 mov r2, #0 <== NOT EXECUTED 20ac0: e58e2000 str r2, [lr] <== NOT EXECUTED 20ac4: e0833000 add r3, r3, r0 <== NOT EXECUTED
break;
20ac8: eafffee1 b 20654 <rtems_nvdisk_ioctl+0x10c> <== NOT EXECUTED
ret = rtems_nvdisk_write_page (nvd, dc->device, page + dc->pages_desc, buffer);
if (ret)
return ret;
return rtems_nvdisk_write_checksum (nvd, dc->device, page, cs);
20acc: e5960000 ldr r0, [r6] <== NOT EXECUTED
* Get the descriptor for a device.
*/
static const rtems_nvdisk_device_desc*
rtems_nvdisk_device_descriptor (const rtems_nvdisk* nvd, uint32_t device)
{
return nvd->devices[device].descriptor;
20ad0: e5973014 ldr r3, [r7, #20] <== NOT EXECUTED 20ad4: e0802100 add r2, r0, r0, lsl #2 <== NOT EXECUTED 20ad8: e0833102 add r3, r3, r2, lsl #2 <== NOT EXECUTED 20adc: e593c010 ldr ip, [r3, #16] <== NOT EXECUTED
ops = nvd->devices[device].descriptor->nv_ops;
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_printf (nvd, " dev-write: %02d-%08x: s=%d",
device, offset, size);
#endif
return ops->write (device, dd->flags, dd->base, offset, buffer, size);
20ae0: e28de01e add lr, sp, #30 <== NOT EXECUTED
20ae4: e89c0006 ldm ip, {r1, r2} <== NOT EXECUTED
20ae8: e59cc00c ldr ip, [ip, #12] <== NOT EXECUTED
20aec: e58de000 str lr, [sp] <== NOT EXECUTED
20af0: e3a0e002 mov lr, #2 <== NOT EXECUTED
ret = rtems_nvdisk_write_page (nvd, dc->device, page + dc->pages_desc, buffer);
if (ret)
return ret;
return rtems_nvdisk_write_checksum (nvd, dc->device, page, cs);
20af4: e1cd41be strh r4, [sp, #30] <== NOT EXECUTED
ops = nvd->devices[device].descriptor->nv_ops;
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_printf (nvd, " dev-write: %02d-%08x: s=%d",
device, offset, size);
#endif
return ops->write (device, dd->flags, dd->base, offset, buffer, size);
20af8: e1a03089 lsl r3, r9, #1 <== NOT EXECUTED 20afc: e58de004 str lr, [sp, #4] <== NOT EXECUTED 20b00: e1a0e00f mov lr, pc <== NOT EXECUTED 20b04: e59cf004 ldr pc, [ip, #4] <== NOT EXECUTED
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
{
ret = rtems_nvdisk_write_block (nvd, sg->block + b, data);
if (ret)
20b08: e3500000 cmp r0, #0 <== NOT EXECUTED 20b0c: 1affffe0 bne 20a94 <rtems_nvdisk_ioctl+0x54c> <== NOT EXECUTED
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
20b10: e2888001 add r8, r8, #1 <== NOT EXECUTED 20b14: e15b0008 cmp fp, r8 <== NOT EXECUTED 20b18: e597300c ldr r3, [r7, #12] <== NOT EXECUTED 20b1c: 80855003 addhi r5, r5, r3 <== NOT EXECUTED 20b20: 8affffb1 bhi 209ec <rtems_nvdisk_ioctl+0x4a4> <== NOT EXECUTED 20b24: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED 20b28: e5904010 ldr r4, [r0, #16] <== NOT EXECUTED
uint8_t* data;
uint32_t nvb;
uint32_t b;
nvb = sg->length / nvd->block_size;
data = sg->buffer;
for (b = 0; b < nvb; b++, data += nvd->block_size)
20b2c: e59d000c ldr r0, [sp, #12] <== NOT EXECUTED 20b30: e2800001 add r0, r0, #1 <== NOT EXECUTED 20b34: e28aa010 add sl, sl, #16 <== NOT EXECUTED 20b38: e58d000c str r0, [sp, #12] <== NOT EXECUTED 20b3c: eaffff9f b 209c0 <rtems_nvdisk_ioctl+0x478> <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "read: blocks=%d", req->bufnum);
#endif
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
20b40: e3a0b000 mov fp, #0 <== NOT EXECUTED 20b44: e1a0100b mov r1, fp <== NOT EXECUTED 20b48: eaffff5d b 208c4 <rtems_nvdisk_ioctl+0x37c> <== NOT EXECUTED
#if RTEMS_NVDISK_TRACE
rtems_nvdisk_info (nvd, "write: blocks=%d", req->bufnum);
#endif
for (bufs = 0; (ret == 0) && (bufs < req->bufnum); bufs++, sg++)
20b4c: e3a01000 mov r1, #0 <== NOT EXECUTED 20b50: eaffffd0 b 20a98 <rtems_nvdisk_ioctl+0x550> <== NOT EXECUTED
00020ea4 <rtems_nvdisk_sram_read>:
uint32_t flags __attribute__((unused)),
void* base,
uint32_t offset,
void* buffer,
size_t size)
{
20ea4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
memcpy (buffer, (base + offset), size);
20ea8: e0821003 add r1, r2, r3 <== NOT EXECUTED
20eac: e99d0005 ldmib sp, {r0, r2} <== NOT EXECUTED
20eb0: eb0094fe bl 462b0 <memcpy> <== NOT EXECUTED
return 0; }
20eb4: e3a00000 mov r0, #0 <== NOT EXECUTED
20eb8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00020e6c <rtems_nvdisk_sram_verify>:
uint32_t flags __attribute__((unused)),
void* base,
uint32_t offset,
const void* buffer,
size_t size)
{
20e6c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
return memcmp ((base + offset), buffer, size) == 0 ? 0 : EIO;
20e70: e0820003 add r0, r2, r3 <== NOT EXECUTED
20e74: e99d0006 ldmib sp, {r1, r2} <== NOT EXECUTED
20e78: eb0094e2 bl 46208 <memcmp> <== NOT EXECUTED
}
20e7c: e3500000 cmp r0, #0 <== NOT EXECUTED
20e80: 13a00005 movne r0, #5 <== NOT EXECUTED
20e84: 03a00000 moveq r0, #0 <== NOT EXECUTED
20e88: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00020e8c <rtems_nvdisk_sram_write>:
uint32_t flags __attribute__((unused)),
void* base,
uint32_t offset,
const void* buffer,
size_t size)
{
20e8c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
memcpy ((base + offset), buffer, size);
20e90: e0820003 add r0, r2, r3 <== NOT EXECUTED
20e94: e99d0006 ldmib sp, {r1, r2} <== NOT EXECUTED
20e98: eb009504 bl 462b0 <memcpy> <== NOT EXECUTED
return 0; }
20e9c: e3a00000 mov r0, #0 <== NOT EXECUTED
20ea0: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00006d0c <rtems_panic>:
void rtems_panic(
const char *printf_format,
...
)
{
6d0c: e92d000f push {r0, r1, r2, r3} <== NOT EXECUTED
6d10: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
6d14: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
va_list arglist;
va_start(arglist, printf_format);
6d18: e28d300c add r3, sp, #12 <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
6d1c: e1a02003 mov r2, r3 <== NOT EXECUTED
6d20: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED
6d24: e3a00202 mov r0, #536870912 ; 0x20000000 <== NOT EXECUTED
...
)
{
va_list arglist;
va_start(arglist, printf_format);
6d28: e58d3000 str r3, [sp] <== NOT EXECUTED
(void) rtems_verror(RTEMS_ERROR_PANIC, printf_format, arglist);
6d2c: ebffff8d bl 6b68 <rtems_verror> <== NOT EXECUTED
va_end(arglist);
}
6d30: e28dd004 add sp, sp, #4 <== NOT EXECUTED
6d34: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
6d38: e28dd010 add sp, sp, #16 <== NOT EXECUTED
6d3c: e12fff1e bx lr <== NOT EXECUTED
0000907c <rtems_pipe_initialize>:
/*
* Initialization of FIFO/pipe module.
*/
void rtems_pipe_initialize (void)
{
907c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
if (!rtems_pipe_configured)
9080: e59f3054 ldr r3, [pc, #84] ; 90dc <rtems_pipe_initialize+0x60>
9084: e5d33000 ldrb r3, [r3]
9088: e3530000 cmp r3, #0
/*
* Initialization of FIFO/pipe module.
*/
void rtems_pipe_initialize (void)
{
908c: e24dd004 sub sp, sp, #4
if (!rtems_pipe_configured)
9090: 0a000003 beq 90a4 <rtems_pipe_initialize+0x28>
return;
if (rtems_pipe_semaphore)
9094: e59fc044 ldr ip, [pc, #68] ; 90e0 <rtems_pipe_initialize+0x64><== NOT EXECUTED
9098: e59c3000 ldr r3, [ip] <== NOT EXECUTED
909c: e3530000 cmp r3, #0 <== NOT EXECUTED
90a0: 0a000001 beq 90ac <rtems_pipe_initialize+0x30> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
rtems_interval now;
now = rtems_clock_get_ticks_since_boot();
rtems_pipe_no = now;
}
90a4: e28dd004 add sp, sp, #4
90a8: e8bd8000 pop {pc}
if (rtems_pipe_semaphore)
return;
rtems_status_code sc;
sc = rtems_semaphore_create(
90ac: e59f0030 ldr r0, [pc, #48] ; 90e4 <rtems_pipe_initialize+0x68><== NOT EXECUTED
90b0: e3a01001 mov r1, #1 <== NOT EXECUTED
90b4: e3a02054 mov r2, #84 ; 0x54 <== NOT EXECUTED
90b8: e58dc000 str ip, [sp] <== NOT EXECUTED
90bc: ebfff11f bl 5540 <rtems_semaphore_create> <== NOT EXECUTED
rtems_build_name ('P', 'I', 'P', 'E'), 1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY, &rtems_pipe_semaphore);
if (sc != RTEMS_SUCCESSFUL)
90c0: e3500000 cmp r0, #0 <== NOT EXECUTED
90c4: 1a000003 bne 90d8 <rtems_pipe_initialize+0x5c> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
rtems_interval now;
now = rtems_clock_get_ticks_since_boot();
90c8: ebfff013 bl 511c <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED
rtems_pipe_no = now;
90cc: e59f3014 ldr r3, [pc, #20] ; 90e8 <rtems_pipe_initialize+0x6c><== NOT EXECUTED
90d0: e1c300b0 strh r0, [r3] <== NOT EXECUTED
90d4: eafffff2 b 90a4 <rtems_pipe_initialize+0x28> <== NOT EXECUTED
sc = rtems_semaphore_create(
rtems_build_name ('P', 'I', 'P', 'E'), 1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY, &rtems_pipe_semaphore);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
90d8: ebfff340 bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
00042260 <rtems_rfs_bitmap_close>:
return rtems_rfs_bitmap_create_search (control);
}
int
rtems_rfs_bitmap_close (rtems_rfs_bitmap_control* control)
{
42260: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
free (control->search_bits);
42264: e5900014 ldr r0, [r0, #20] <== NOT EXECUTED 42268: ebff16c0 bl 7d70 <free> <== NOT EXECUTED
return 0; }
4226c: e3a00000 mov r0, #0 <== NOT EXECUTED
42270: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
000422c4 <rtems_rfs_bitmap_create_search>:
return 0;
}
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
422c4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
422c8: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
422cc: e1a0100d mov r1, sp <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_create_search (rtems_rfs_bitmap_control* control)
{
422d0: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
size_t size;
rtems_rfs_bitmap_bit bit;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
422d4: ebffffe6 bl 42274 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
422d8: e3500000 cmp r0, #0 <== NOT EXECUTED 422dc: da000001 ble 422e8 <rtems_rfs_bitmap_create_search+0x24> <== NOT EXECUTED
bit++;
map++;
}
return 0;
}
422e0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
422e4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
if (rc > 0)
return rc;
control->free = 0;
search_map = control->search_bits;
size = control->size;
422e8: e594000c ldr r0, [r4, #12] <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
search_map = control->search_bits;
422ec: e594b014 ldr fp, [r4, #20] <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
422f0: e3a06000 mov r6, #0 <== NOT EXECUTED
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
422f4: e3e09000 mvn r9, #0 <== NOT EXECUTED
while (size)
422f8: e3500000 cmp r0, #0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
control->free = 0;
422fc: e5846010 str r6, [r4, #16] <== NOT EXECUTED
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
42300: e58b9000 str r9, [fp] <== NOT EXECUTED
while (size)
42304: 0a00001d beq 42380 <rtems_rfs_bitmap_create_search+0xbc> <== NOT EXECUTED 42308: e59da000 ldr sl, [sp] <== NOT EXECUTED 4230c: e1a07006 mov r7, r6 <== NOT EXECUTED
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
42310: e3a0c001 mov ip, #1 <== NOT EXECUTED
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
{
rtems_rfs_bitmap_element bits;
int available;
if (size < rtems_rfs_bitmap_element_bits ())
42314: e350001f cmp r0, #31 <== NOT EXECUTED
{
/*
* Use the normal bit operators because we do not change the bits just merge
* the 2 separate parts.
*/
bits1 &= mask;
42318: 979a3006 ldrls r3, [sl, r6] <== NOT EXECUTED 4231c: 92602020 rsbls r2, r0, #32 <== NOT EXECUTED 42320: 90032239 andls r2, r3, r9, lsr r2 <== NOT EXECUTED
rtems_rfs_bitmap_mask_section (0, size));
available = size;
}
else
{
bits = *map;
42324: 879a2006 ldrhi r2, [sl, r6] <== NOT EXECUTED 42328: 83a08020 movhi r8, #32 <== NOT EXECUTED
if (size < rtems_rfs_bitmap_element_bits ())
{
bits = rtems_rfs_bitmap_merge (*map,
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask_section (0, size));
available = size;
4232c: 91a01000 movls r1, r0 <== NOT EXECUTED 42330: 91a08000 movls r8, r0 <== NOT EXECUTED
}
else
{
bits = *map;
42334: 81a01008 movhi r1, r8 <== NOT EXECUTED
available = rtems_rfs_bitmap_element_bits ();
}
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
42338: e3520000 cmp r2, #0 <== NOT EXECUTED 4233c: 0a000007 beq 42360 <rtems_rfs_bitmap_create_search+0x9c> <== NOT EXECUTED 42340: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
42344: e012531c ands r5, r2, ip, lsl r3 <== NOT EXECUTED
control->free++;
42348: 15945010 ldrne r5, [r4, #16] <== NOT EXECUTED
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
4234c: e2833001 add r3, r3, #1 <== NOT EXECUTED
if (!rtems_rfs_bitmap_test (bits, b))
control->free++;
42350: 12855001 addne r5, r5, #1 <== NOT EXECUTED 42354: 15845010 strne r5, [r4, #16] <== NOT EXECUTED
if (rtems_rfs_bitmap_match (bits, RTEMS_RFS_BITMAP_ELEMENT_SET))
rtems_rfs_bitmap_set (*search_map, bit);
else
{
int b;
for (b = 0; b < available; b++)
42358: e1510003 cmp r1, r3 <== NOT EXECUTED 4235c: cafffff8 bgt 42344 <rtems_rfs_bitmap_create_search+0x80> <== NOT EXECUTED
control->free++;
}
size -= available;
if (bit == rtems_rfs_bitmap_element_bits ())
42360: e3570020 cmp r7, #32 <== NOT EXECUTED
for (b = 0; b < available; b++)
if (!rtems_rfs_bitmap_test (bits, b))
control->free++;
}
size -= available;
42364: e0680000 rsb r0, r8, r0 <== NOT EXECUTED
if (bit == rtems_rfs_bitmap_element_bits ())
{
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
42368: 05ab9004 streq r9, [fp, #4]! <== NOT EXECUTED 4236c: 03a07000 moveq r7, #0 <== NOT EXECUTED
}
else
bit++;
42370: 12877001 addne r7, r7, #1 <== NOT EXECUTED
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
42374: e3500000 cmp r0, #0 <== NOT EXECUTED
bit = 0;
search_map++;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
}
else
bit++;
42378: e2866004 add r6, r6, #4 <== NOT EXECUTED
search_map = control->search_bits;
size = control->size;
bit = 0;
*search_map = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
while (size)
4237c: 1affffe4 bne 42314 <rtems_rfs_bitmap_create_search+0x50> <== NOT EXECUTED 42380: e3a00000 mov r0, #0 <== NOT EXECUTED 42384: eaffffd5 b 422e0 <rtems_rfs_bitmap_create_search+0x1c> <== NOT EXECUTED
00042274 <rtems_rfs_bitmap_load_map>:
rtems_rfs_bitmap_load_map (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_map* map)
{
int rc;
if (!control->buffer)
42274: e5903000 ldr r3, [r0] <== NOT EXECUTED 42278: e3530000 cmp r3, #0 <== NOT EXECUTED
* @return int The error number (errno). No error if 0.
*/
static int
rtems_rfs_bitmap_load_map (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_map* map)
{
4227c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
42280: e1a04000 mov r4, r0 <== NOT EXECUTED
42284: e1a05001 mov r5, r1 <== NOT EXECUTED
int rc;
if (!control->buffer)
42288: 03a00006 moveq r0, #6 <== NOT EXECUTED
4228c: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
return ENXIO;
*map = NULL;
42290: e3a02000 mov r2, #0 <== NOT EXECUTED 42294: e5812000 str r2, [r1] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (control->fs,
42298: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 4229c: e1a01003 mov r1, r3 <== NOT EXECUTED 422a0: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 422a4: e3a03001 mov r3, #1 <== NOT EXECUTED 422a8: ebffdde9 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
control->buffer,
control->block,
true);
if (rc)
422ac: e3500000 cmp r0, #0 <== NOT EXECUTED
return rc;
*map = rtems_rfs_buffer_data (control->buffer);
422b0: 05943000 ldreq r3, [r4] <== NOT EXECUTED 422b4: 05933008 ldreq r3, [r3, #8] <== NOT EXECUTED 422b8: 05933020 ldreq r3, [r3, #32] <== NOT EXECUTED 422bc: 05853000 streq r3, [r5] <== NOT EXECUTED
return 0; }
422c0: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
0004295c <rtems_rfs_bitmap_map_alloc>:
int
rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit seed,
bool* allocated,
rtems_rfs_bitmap_bit* bit)
{
4295c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
42960: e1a07002 mov r7, r2 <== NOT EXECUTED
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
42964: e3a02000 mov r2, #0 <== NOT EXECUTED 42968: e1a05001 mov r5, r1 <== NOT EXECUTED 4296c: e5c72000 strb r2, [r7] <== NOT EXECUTED
int
rtems_rfs_bitmap_map_alloc (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit seed,
bool* allocated,
rtems_rfs_bitmap_bit* bit)
{
42970: e1a06000 mov r6, r0 <== NOT EXECUTED 42974: e1a08003 mov r8, r3 <== NOT EXECUTED
int rc = 0;
/*
* By default we assume the allocation failed.
*/
*allocated = false;
42978: e1a04001 mov r4, r1 <== NOT EXECUTED
* we have searched all of the map. The seed may not be aligned to a window * boundary so we may need to search a partial window and this may also not * be balanced for the upper or lower seeds. We move to the limits, search * then return false if no clear bits are found. */ while (((upper_seed >= 0) && (upper_seed < control->size))
4297c: ea000011 b 429c8 <rtems_rfs_bitmap_map_alloc+0x6c> <== NOT EXECUTED
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
{
*bit = upper_seed;
42980: e5884000 str r4, [r8] <== NOT EXECUTED
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
42984: e1a00006 mov r0, r6 <== NOT EXECUTED 42988: e1a01008 mov r1, r8 <== NOT EXECUTED 4298c: e1a02007 mov r2, r7 <== NOT EXECUTED 42990: e3a03001 mov r3, #1 <== NOT EXECUTED 42994: ebffff3f bl 42698 <T.57> <== NOT EXECUTED
window, 1);
if ((rc > 0) || *allocated)
42998: e3500000 cmp r0, #0 <== NOT EXECUTED 4299c: ca000020 bgt 42a24 <rtems_rfs_bitmap_map_alloc+0xc8> <== NOT EXECUTED 429a0: e5d73000 ldrb r3, [r7] <== NOT EXECUTED 429a4: e3530000 cmp r3, #0 <== NOT EXECUTED 429a8: 1a00001d bne 42a24 <rtems_rfs_bitmap_map_alloc+0xc8> <== NOT EXECUTED
break;
}
if (lower_seed >= 0)
429ac: e3550000 cmp r5, #0 <== NOT EXECUTED 429b0: aa000010 bge 429f8 <rtems_rfs_bitmap_map_alloc+0x9c> <== NOT EXECUTED
/*
* Do not bound the limits at the edges of the map. Do not update if an
* edge has been passed.
*/
if (upper_seed < control->size)
429b4: e596300c ldr r3, [r6, #12] <== NOT EXECUTED 429b8: e1530004 cmp r3, r4 <== NOT EXECUTED
upper_seed += window;
429bc: 82844b02 addhi r4, r4, #2048 ; 0x800 <== NOT EXECUTED
if (lower_seed >= 0)
429c0: e3550000 cmp r5, #0 <== NOT EXECUTED
lower_seed -= window;
429c4: a2455b02 subge r5, r5, #2048 ; 0x800 <== NOT EXECUTED
* we have searched all of the map. The seed may not be aligned to a window * boundary so we may need to search a partial window and this may also not * be balanced for the upper or lower seeds. We move to the limits, search * then return false if no clear bits are found. */ while (((upper_seed >= 0) && (upper_seed < control->size))
429c8: e3540000 cmp r4, #0 <== NOT EXECUTED 429cc: ba000002 blt 429dc <rtems_rfs_bitmap_map_alloc+0x80> <== NOT EXECUTED 429d0: e596300c ldr r3, [r6, #12] <== NOT EXECUTED 429d4: e1540003 cmp r4, r3 <== NOT EXECUTED 429d8: 3affffe8 bcc 42980 <rtems_rfs_bitmap_map_alloc+0x24> <== NOT EXECUTED 429dc: e3550000 cmp r5, #0 <== NOT EXECUTED 429e0: ba00000f blt 42a24 <rtems_rfs_bitmap_map_alloc+0xc8> <== NOT EXECUTED
|| ((lower_seed >= 0) && (lower_seed < control->size)))
429e4: e596300c ldr r3, [r6, #12] <== NOT EXECUTED
* we have searched all of the map. The seed may not be aligned to a window * boundary so we may need to search a partial window and this may also not * be balanced for the upper or lower seeds. We move to the limits, search * then return false if no clear bits are found. */ while (((upper_seed >= 0) && (upper_seed < control->size))
429e8: e1550003 cmp r5, r3 <== NOT EXECUTED 429ec: 2a00000c bcs 42a24 <rtems_rfs_bitmap_map_alloc+0xc8> <== NOT EXECUTED
|| ((lower_seed >= 0) && (lower_seed < control->size)))
{
/*
* Search up first so bits allocated in succession are grouped together.
*/
if (upper_seed < control->size)
429f0: e1540003 cmp r4, r3 <== NOT EXECUTED 429f4: 3affffe1 bcc 42980 <rtems_rfs_bitmap_map_alloc+0x24> <== NOT EXECUTED
break;
}
if (lower_seed >= 0)
{
*bit = lower_seed;
429f8: e5885000 str r5, [r8] <== NOT EXECUTED
rc = rtems_rfs_search_map_for_clear_bit (control, bit, allocated,
429fc: e1a00006 mov r0, r6 <== NOT EXECUTED 42a00: e1a01008 mov r1, r8 <== NOT EXECUTED 42a04: e1a02007 mov r2, r7 <== NOT EXECUTED 42a08: e3e03000 mvn r3, #0 <== NOT EXECUTED 42a0c: ebffff21 bl 42698 <T.57> <== NOT EXECUTED
window, -1);
if ((rc > 0) || *allocated)
42a10: e3500000 cmp r0, #0 <== NOT EXECUTED 42a14: ca000002 bgt 42a24 <rtems_rfs_bitmap_map_alloc+0xc8> <== NOT EXECUTED 42a18: e5d73000 ldrb r3, [r7] <== NOT EXECUTED 42a1c: e3530000 cmp r3, #0 <== NOT EXECUTED 42a20: 0affffe3 beq 429b4 <rtems_rfs_bitmap_map_alloc+0x58> <== NOT EXECUTED
if (lower_seed >= 0)
lower_seed -= window;
}
return 0;
}
42a24: e3a00000 mov r0, #0 <== NOT EXECUTED
42a28: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00042580 <rtems_rfs_bitmap_map_clear>:
}
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
42580: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
42584: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
42588: e1a05001 mov r5, r1 <== NOT EXECUTED
rtems_rfs_bitmap_map map; rtems_rfs_bitmap_map search_map; int index; int offset; int rc; rc = rtems_rfs_bitmap_load_map (control, &map);
4258c: e1a0100d mov r1, sp <== NOT EXECUTED
}
int
rtems_rfs_bitmap_map_clear (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
42590: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_rfs_bitmap_map map; rtems_rfs_bitmap_map search_map; int index; int offset; int rc; rc = rtems_rfs_bitmap_load_map (control, &map);
42594: ebffff36 bl 42274 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
42598: e3500000 cmp r0, #0 <== NOT EXECUTED 4259c: da000001 ble 425a8 <rtems_rfs_bitmap_map_clear+0x28> <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset(bit); search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset); rtems_rfs_buffer_mark_dirty (control->buffer); control->free++; return 0; }
425a0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
425a4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
425a8: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 425ac: e1550003 cmp r5, r3 <== NOT EXECUTED 425b0: 23a00016 movcs r0, #22 <== NOT EXECUTED 425b4: 2afffff9 bcs 425a0 <rtems_rfs_bitmap_map_clear+0x20> <== NOT EXECUTED
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
425b8: e59d1000 ldr r1, [sp] <== NOT EXECUTED
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
425bc: e1a022c5 asr r2, r5, #5 <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset (bit); map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset);
425c0: e7910102 ldr r0, [r1, r2, lsl #2] <== NOT EXECUTED 425c4: e3a03001 mov r3, #1 <== NOT EXECUTED 425c8: e205c01f and ip, r5, #31 <== NOT EXECUTED 425cc: e1800c13 orr r0, r0, r3, lsl ip <== NOT EXECUTED 425d0: e7810102 str r0, [r1, r2, lsl #2] <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
425d4: e5941014 ldr r1, [r4, #20] <== NOT EXECUTED
offset = rtems_rfs_bitmap_map_offset (bit); map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset); bit = index; index = rtems_rfs_bitmap_map_index (bit); offset = rtems_rfs_bitmap_map_offset(bit); search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset);
425d8: e1a05545 asr r5, r5, #10 <== NOT EXECUTED 425dc: e7910105 ldr r0, [r1, r5, lsl #2] <== NOT EXECUTED 425e0: e202201f and r2, r2, #31 <== NOT EXECUTED 425e4: e1802213 orr r2, r0, r3, lsl r2 <== NOT EXECUTED 425e8: e7812105 str r2, [r1, r5, lsl #2] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer); control->free++;
425ec: e5942010 ldr r2, [r4, #16] <== NOT EXECUTED
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset); bit = index; index = rtems_rfs_bitmap_map_index (bit); offset = rtems_rfs_bitmap_map_offset(bit); search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset); rtems_rfs_buffer_mark_dirty (control->buffer);
425f0: e5941000 ldr r1, [r4] <== NOT EXECUTED
control->free++;
425f4: e0822003 add r2, r2, r3 <== NOT EXECUTED
map[index] = rtems_rfs_bitmap_clear (map[index], 1 << offset); bit = index; index = rtems_rfs_bitmap_map_index (bit); offset = rtems_rfs_bitmap_map_offset(bit); search_map[index] = rtems_rfs_bitmap_clear (search_map[index], 1 << offset); rtems_rfs_buffer_mark_dirty (control->buffer);
425f8: e5c13000 strb r3, [r1] <== NOT EXECUTED
control->free++;
425fc: e5842010 str r2, [r4, #16] <== NOT EXECUTED 42600: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
42604: eaffffe5 b 425a0 <rtems_rfs_bitmap_map_clear+0x20> <== NOT EXECUTED
000423d0 <rtems_rfs_bitmap_map_clear_all>:
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
423d0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
423d4: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
423d8: e1a0100d mov r1, sp <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
{
423dc: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_rfs_bitmap_bit last_search_bit;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
423e0: ebffffa3 bl 42274 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
423e4: e3500000 cmp r0, #0 <== NOT EXECUTED 423e8: da000001 ble 423f4 <rtems_rfs_bitmap_map_clear_all+0x24> <== NOT EXECUTED
rtems_rfs_bitmap_mask (last_search_bit));
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
423ec: e28dd004 add sp, sp, #4 <== NOT EXECUTED
423f0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
423f4: e594500c ldr r5, [r4, #12] <== NOT EXECUTED 423f8: e2455001 sub r5, r5, #1 <== NOT EXECUTED 423fc: e1a052a5 lsr r5, r5, #5 <== NOT EXECUTED 42400: e2851001 add r1, r5, #1 <== NOT EXECUTED
control->free = elements;
42404: e3a02000 mov r2, #0 <== NOT EXECUTED 42408: e5841010 str r1, [r4, #16] <== NOT EXECUTED 4240c: e59dc000 ldr ip, [sp] <== NOT EXECUTED 42410: e1a03002 mov r3, r2 <== NOT EXECUTED
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
42414: e3e00000 mvn r0, #0 <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
42418: e2833001 add r3, r3, #1 <== NOT EXECUTED 4241c: e1510003 cmp r1, r3 <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
42420: e78c0102 str r0, [ip, r2, lsl #2] <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = elements;
for (e = 0; e < elements; e++)
42424: e1a02003 mov r2, r3 <== NOT EXECUTED 42428: 8afffffa bhi 42418 <rtems_rfs_bitmap_map_clear_all+0x48> <== NOT EXECUTED
* Set the un-mapped bits in the last search element so the available logic
* works.
*/
last_search_bit = rtems_rfs_bitmap_map_offset (elements);
if (last_search_bit == 0)
4242c: e211101f ands r1, r1, #31 <== NOT EXECUTED 42430: 12611020 rsbne r1, r1, #32 <== NOT EXECUTED 42434: 01a06000 moveq r6, r0 <== NOT EXECUTED 42438: 11a06130 lsrne r6, r0, r1 <== NOT EXECUTED
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
4243c: e1b012a5 lsrs r1, r5, #5 <== NOT EXECUTED 42440: 05940014 ldreq r0, [r4, #20] <== NOT EXECUTED 42444: 0a000008 beq 4246c <rtems_rfs_bitmap_map_clear_all+0x9c> <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
42448: e3a02000 mov r2, #0 <== NOT EXECUTED
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
4244c: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_map_clear_all (rtems_rfs_bitmap_control* control)
42450: e1a03002 mov r3, r2 <== NOT EXECUTED
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
42454: e3e0c000 mvn ip, #0 <== NOT EXECUTED
if (last_search_bit == 0)
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
42458: e2833001 add r3, r3, #1 <== NOT EXECUTED 4245c: e1530001 cmp r3, r1 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
42460: e780c102 str ip, [r0, r2, lsl #2] <== NOT EXECUTED
if (last_search_bit == 0)
last_search_bit = rtems_rfs_bitmap_element_bits ();
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
42464: e1a02003 mov r2, r3 <== NOT EXECUTED 42468: 1afffffa bne 42458 <rtems_rfs_bitmap_map_clear_all+0x88> <== NOT EXECUTED
control->search_bits[elements - 1] =
rtems_rfs_bitmap_merge (RTEMS_RFS_BITMAP_ELEMENT_CLEAR,
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask (last_search_bit));
rtems_rfs_buffer_mark_dirty (control->buffer);
4246c: e5943000 ldr r3, [r4] <== NOT EXECUTED 42470: e3a02001 mov r2, #1 <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < (elements - 1); e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_CLEAR;
control->search_bits[elements - 1] =
42474: e7806101 str r6, [r0, r1, lsl #2] <== NOT EXECUTED
rtems_rfs_bitmap_merge (RTEMS_RFS_BITMAP_ELEMENT_CLEAR,
RTEMS_RFS_BITMAP_ELEMENT_SET,
rtems_rfs_bitmap_mask (last_search_bit));
rtems_rfs_buffer_mark_dirty (control->buffer);
42478: e5c32000 strb r2, [r3] <== NOT EXECUTED 4247c: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
42480: eaffffd9 b 423ec <rtems_rfs_bitmap_map_clear_all+0x1c> <== NOT EXECUTED
00042608 <rtems_rfs_bitmap_map_set>:
}
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
42608: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
4260c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
42610: e1a05001 mov r5, r1 <== NOT EXECUTED
rtems_rfs_bitmap_map map; rtems_rfs_bitmap_map search_map; int index; int offset; int rc; rc = rtems_rfs_bitmap_load_map (control, &map);
42614: e1a0100d mov r1, sp <== NOT EXECUTED
}
int
rtems_rfs_bitmap_map_set (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit)
{
42618: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_rfs_bitmap_map map; rtems_rfs_bitmap_map search_map; int index; int offset; int rc; rc = rtems_rfs_bitmap_load_map (control, &map);
4261c: ebffff14 bl 42274 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
42620: e3500000 cmp r0, #0 <== NOT EXECUTED 42624: da000001 ble 42630 <rtems_rfs_bitmap_map_set+0x28> <== NOT EXECUTED
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
rtems_rfs_buffer_mark_dirty (control->buffer);
}
return 0;
}
42628: e28dd004 add sp, sp, #4 <== NOT EXECUTED
4262c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
int offset;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
42630: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 42634: e1550003 cmp r5, r3 <== NOT EXECUTED 42638: 23a00016 movcs r0, #22 <== NOT EXECUTED 4263c: 2afffff9 bcs 42628 <rtems_rfs_bitmap_map_set+0x20> <== NOT EXECUTED
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
42640: e59d1000 ldr r1, [sp] <== NOT EXECUTED
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
42644: e1a032c5 asr r3, r5, #5 <== NOT EXECUTED
*/
static rtems_rfs_bitmap_element
rtems_rfs_bitmap_set (rtems_rfs_bitmap_element target,
rtems_rfs_bitmap_element bits)
{
return RTEMS_RFS_BITMAP_SET_BITS (target, bits);
42648: e7910103 ldr r0, [r1, r3, lsl #2] <== NOT EXECUTED 4264c: e205c01f and ip, r5, #31 <== NOT EXECUTED 42650: e3a02001 mov r2, #1 <== NOT EXECUTED 42654: e1c00c12 bic r0, r0, r2, lsl ip <== NOT EXECUTED
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
42658: e3500000 cmp r0, #0 <== NOT EXECUTED
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset);
4265c: e7810103 str r0, [r1, r3, lsl #2] <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
return EINVAL;
search_map = control->search_bits;
42660: e5941014 ldr r1, [r4, #20] <== NOT EXECUTED
index = rtems_rfs_bitmap_map_index (bit); offset = rtems_rfs_bitmap_map_offset (bit); map[index] = rtems_rfs_bitmap_set (map[index], 1 << offset); if (rtems_rfs_bitmap_match(map[index], RTEMS_RFS_BITMAP_ELEMENT_SET))
42664: 13a00000 movne r0, #0 <== NOT EXECUTED 42668: 1affffee bne 42628 <rtems_rfs_bitmap_map_set+0x20> <== NOT EXECUTED
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
4266c: e1a05545 asr r5, r5, #10 <== NOT EXECUTED 42670: e791c105 ldr ip, [r1, r5, lsl #2] <== NOT EXECUTED 42674: e203301f and r3, r3, #31 <== NOT EXECUTED 42678: e1cc3312 bic r3, ip, r2, lsl r3 <== NOT EXECUTED 4267c: e7813105 str r3, [r1, r5, lsl #2] <== NOT EXECUTED
control->free--;
42680: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
42684: e5941000 ldr r1, [r4] <== NOT EXECUTED
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
42688: e2433001 sub r3, r3, #1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (control->buffer);
4268c: e5c12000 strb r2, [r1] <== NOT EXECUTED
{
bit = index;
index = rtems_rfs_bitmap_map_index (bit);
offset = rtems_rfs_bitmap_map_offset (bit);
search_map[index] = rtems_rfs_bitmap_set (search_map[index], 1 << offset);
control->free--;
42690: e5843010 str r3, [r4, #16] <== NOT EXECUTED 42694: eaffffe3 b 42628 <rtems_rfs_bitmap_map_set+0x20> <== NOT EXECUTED
00042484 <rtems_rfs_bitmap_map_set_all>:
return 0;
}
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
42484: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
42488: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
4248c: e1a0100d mov r1, sp <== NOT EXECUTED
return 0;
}
int
rtems_rfs_bitmap_map_set_all (rtems_rfs_bitmap_control* control)
{
42490: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_rfs_bitmap_map map;
size_t elements;
int e;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
42494: ebffff76 bl 42274 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
42498: e3500000 cmp r0, #0 <== NOT EXECUTED 4249c: da000001 ble 424a8 <rtems_rfs_bitmap_map_set_all+0x24> <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
rtems_rfs_buffer_mark_dirty (control->buffer);
return 0;
}
424a0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
424a4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
424a8: e594500c ldr r5, [r4, #12] <== NOT EXECUTED
control->free = 0;
424ac: e3a03000 mov r3, #0 <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
424b0: e2455001 sub r5, r5, #1 <== NOT EXECUTED 424b4: e1a052a5 lsr r5, r5, #5 <== NOT EXECUTED
control->free = 0;
424b8: e5843010 str r3, [r4, #16] <== NOT EXECUTED 424bc: e59dc000 ldr ip, [sp] <== NOT EXECUTED 424c0: e1a02003 mov r2, r3 <== NOT EXECUTED
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
elements = rtems_rfs_bitmap_elements (control->size);
424c4: e2850001 add r0, r5, #1 <== NOT EXECUTED
control->free = 0;
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
424c8: e1a01003 mov r1, r3 <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
for (e = 0; e < elements; e++)
424cc: e2833001 add r3, r3, #1 <== NOT EXECUTED 424d0: e1500003 cmp r0, r3 <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
424d4: e78c1102 str r1, [ip, r2, lsl #2] <== NOT EXECUTED
elements = rtems_rfs_bitmap_elements (control->size);
control->free = 0;
for (e = 0; e < elements; e++)
424d8: e1a02003 mov r2, r3 <== NOT EXECUTED 424dc: 8afffffa bhi 424cc <rtems_rfs_bitmap_map_set_all+0x48> <== NOT EXECUTED
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < elements; e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
424e0: e1a02001 mov r2, r1 <== NOT EXECUTED 424e4: e594c014 ldr ip, [r4, #20] <== NOT EXECUTED
control->free = 0;
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
424e8: e1a012a5 lsr r1, r5, #5 <== NOT EXECUTED 424ec: e2811001 add r1, r1, #1 <== NOT EXECUTED
for (e = 0; e < elements; e++)
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
424f0: e1a03002 mov r3, r2 <== NOT EXECUTED 424f4: e1a00002 mov r0, r2 <== NOT EXECUTED
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < elements; e++)
424f8: e2833001 add r3, r3, #1 <== NOT EXECUTED 424fc: e1530001 cmp r3, r1 <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
42500: e78c0102 str r0, [ip, r2, lsl #2] <== NOT EXECUTED
for (e = 0; e < elements; e++)
map[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
elements = rtems_rfs_bitmap_elements (elements);
for (e = 0; e < elements; e++)
42504: e1a02003 mov r2, r3 <== NOT EXECUTED 42508: 3afffffa bcc 424f8 <rtems_rfs_bitmap_map_set_all+0x74> <== NOT EXECUTED
control->search_bits[e] = RTEMS_RFS_BITMAP_ELEMENT_SET;
rtems_rfs_buffer_mark_dirty (control->buffer);
4250c: e5943000 ldr r3, [r4] <== NOT EXECUTED 42510: e3a02001 mov r2, #1 <== NOT EXECUTED 42514: e5c32000 strb r2, [r3] <== NOT EXECUTED
return 0;
42518: eaffffe0 b 424a0 <rtems_rfs_bitmap_map_set_all+0x1c> <== NOT EXECUTED
0004251c <rtems_rfs_bitmap_map_test>:
int
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit,
bool* state)
{
4251c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
42520: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
42524: e1a04001 mov r4, r1 <== NOT EXECUTED
rtems_rfs_bitmap_map map; int index; int rc; rc = rtems_rfs_bitmap_load_map (control, &map);
42528: e1a0100d mov r1, sp <== NOT EXECUTED
int
rtems_rfs_bitmap_map_test (rtems_rfs_bitmap_control* control,
rtems_rfs_bitmap_bit bit,
bool* state)
{
4252c: e1a06002 mov r6, r2 <== NOT EXECUTED 42530: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_rfs_bitmap_map map; int index; int rc; rc = rtems_rfs_bitmap_load_map (control, &map);
42534: ebffff4e bl 42274 <rtems_rfs_bitmap_load_map> <== NOT EXECUTED
if (rc > 0)
42538: e3500000 cmp r0, #0 <== NOT EXECUTED 4253c: da000001 ble 42548 <rtems_rfs_bitmap_map_test+0x2c> <== NOT EXECUTED
if (bit >= control->size)
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
*state = rtems_rfs_bitmap_test (map[index], bit);
return 0;
}
42540: e28dd004 add sp, sp, #4 <== NOT EXECUTED
42544: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
int index;
int rc;
rc = rtems_rfs_bitmap_load_map (control, &map);
if (rc > 0)
return rc;
if (bit >= control->size)
42548: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 4254c: e1540003 cmp r4, r3 <== NOT EXECUTED 42550: 23a00016 movcs r0, #22 <== NOT EXECUTED 42554: 2afffff9 bcs 42540 <rtems_rfs_bitmap_map_test+0x24> <== NOT EXECUTED
return EINVAL;
index = rtems_rfs_bitmap_map_index (bit);
*state = rtems_rfs_bitmap_test (map[index], bit);
42558: e59d3000 ldr r3, [sp] <== NOT EXECUTED 4255c: e1a022c4 asr r2, r4, #5 <== NOT EXECUTED 42560: e7933102 ldr r3, [r3, r2, lsl #2] <== NOT EXECUTED 42564: e3a02001 mov r2, #1 <== NOT EXECUTED 42568: e0133412 ands r3, r3, r2, lsl r4 <== NOT EXECUTED 4256c: 13a03000 movne r3, #0 <== NOT EXECUTED 42570: 03a03001 moveq r3, #1 <== NOT EXECUTED 42574: e5c63000 strb r3, [r6] <== NOT EXECUTED 42578: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
4257c: eaffffef b 42540 <rtems_rfs_bitmap_map_test+0x24> <== NOT EXECUTED
00042230 <rtems_rfs_bitmap_mask>:
return 0;
}
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask (unsigned int size)
{
42230: e3e03000 mvn r3, #0 <== NOT EXECUTED 42234: e2600020 rsb r0, r0, #32 <== NOT EXECUTED
rtems_rfs_bitmap_element mask = RTEMS_RFS_BITMAP_ELEMENT_FULL_MASK; mask >>= (rtems_rfs_bitmap_element_bits () - size); return mask; }
42238: e1a00033 lsr r0, r3, r0 <== NOT EXECUTED 4223c: e12fff1e bx lr <== NOT EXECUTED
00042240 <rtems_rfs_bitmap_mask_section>:
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
if (end > start)
42240: e1510000 cmp r1, r0 <== NOT EXECUTED
mask = rtems_rfs_bitmap_mask (end - start) << start;
42244: 80601001 rsbhi r1, r0, r1 <== NOT EXECUTED 42248: 82611020 rsbhi r1, r1, #32 <== NOT EXECUTED 4224c: 83e03000 mvnhi r3, #0 <== NOT EXECUTED 42250: 81a01133 lsrhi r1, r3, r1 <== NOT EXECUTED
rtems_rfs_bitmap_element
rtems_rfs_bitmap_mask_section (unsigned int start, unsigned int end)
{
rtems_rfs_bitmap_element mask = 0;
if (end > start)
42254: 93a00000 movls r0, #0 <== NOT EXECUTED
mask = rtems_rfs_bitmap_mask (end - start) << start;
42258: 81a00011 lslhi r0, r1, r0 <== NOT EXECUTED
return mask; }
4225c: e12fff1e bx lr <== NOT EXECUTED
00042388 <rtems_rfs_bitmap_open>:
rtems_rfs_bitmap_open (rtems_rfs_bitmap_control* control,
rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
size_t size,
rtems_rfs_buffer_block block)
{
42388: e92d4010 push {r4, lr} <== NOT EXECUTED
control->fs = fs;
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
4238c: e243c001 sub ip, r3, #1 <== NOT EXECUTED
rtems_rfs_bitmap_open (rtems_rfs_bitmap_control* control,
rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
size_t size,
rtems_rfs_buffer_block block)
{
42390: e1a04000 mov r4, r0 <== NOT EXECUTED
control->fs = fs;
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
42394: e1a0c52c lsr ip, ip, #10 <== NOT EXECUTED
size_t size,
rtems_rfs_buffer_block block)
{
size_t elements = rtems_rfs_bitmap_elements (size);
control->buffer = buffer;
42398: e5842000 str r2, [r4] <== NOT EXECUTED
control->fs = fs; control->block = block;
4239c: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
423a0: e28c0001 add r0, ip, #1 <== NOT EXECUTED
rtems_rfs_buffer_block block)
{
size_t elements = rtems_rfs_bitmap_elements (size);
control->buffer = buffer;
control->fs = fs;
423a4: e984000e stmib r4, {r1, r2, r3} <== NOT EXECUTED
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
423a8: e1a00100 lsl r0, r0, #2 <== NOT EXECUTED 423ac: ebff1833 bl 8480 <malloc> <== NOT EXECUTED
if (!control->search_bits)
423b0: e3500000 cmp r0, #0 <== NOT EXECUTED
control->fs = fs;
control->block = block;
control->size = size;
elements = rtems_rfs_bitmap_elements (elements);
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
423b4: e5840014 str r0, [r4, #20] <== NOT EXECUTED
if (!control->search_bits)
423b8: 0a000002 beq 423c8 <rtems_rfs_bitmap_open+0x40> <== NOT EXECUTED
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
423bc: e1a00004 mov r0, r4 <== NOT EXECUTED
}
423c0: e8bd4010 pop {r4, lr} <== NOT EXECUTED
control->search_bits = malloc (elements * sizeof (rtems_rfs_bitmap_element));
if (!control->search_bits)
return ENOMEM;
return rtems_rfs_bitmap_create_search (control);
423c4: eaffffbe b 422c4 <rtems_rfs_bitmap_create_search> <== NOT EXECUTED
}
423c8: e3a0000c mov r0, #12 <== NOT EXECUTED
423cc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00038904 <rtems_rfs_block_find_indirect>:
rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no block,
int offset,
rtems_rfs_block_no* result)
{
38904: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
38908: e1a04003 mov r4, r3 <== NOT EXECUTED
/*
* If the handle has a buffer and this request is a different block the current
* buffer is released.
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
3890c: e3a03001 mov r3, #1 <== NOT EXECUTED
rtems_rfs_block_find_indirect (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no block,
int offset,
rtems_rfs_block_no* result)
{
38910: e1a06000 mov r6, r0 <== NOT EXECUTED 38914: e1a07001 mov r7, r1 <== NOT EXECUTED 38918: e59d5014 ldr r5, [sp, #20] <== NOT EXECUTED
/*
* If the handle has a buffer and this request is a different block the current
* buffer is released.
*/
rc = rtems_rfs_buffer_handle_request (fs, buffer, block, true);
3891c: eb00044c bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
38920: e3500000 cmp r0, #0 <== NOT EXECUTED
38924: c8bd80f0 popgt {r4, r5, r6, r7, pc} <== NOT EXECUTED
return rc;
*result = rtems_rfs_block_get_number (buffer, offset);
38928: e5973008 ldr r3, [r7, #8] <== NOT EXECUTED 3892c: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED 38930: e0821104 add r1, r2, r4, lsl #2 <== NOT EXECUTED 38934: e7d20104 ldrb r0, [r2, r4, lsl #2] <== NOT EXECUTED 38938: e5d13003 ldrb r3, [r1, #3] <== NOT EXECUTED 3893c: e1a04001 mov r4, r1 <== NOT EXECUTED 38940: e5d11001 ldrb r1, [r1, #1] <== NOT EXECUTED 38944: e5d42002 ldrb r2, [r4, #2] <== NOT EXECUTED 38948: e1833c00 orr r3, r3, r0, lsl #24 <== NOT EXECUTED 3894c: e1833801 orr r3, r3, r1, lsl #16 <== NOT EXECUTED 38950: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
if ((*result + 1) == 0)
38954: e3730001 cmn r3, #1 <== NOT EXECUTED 38958: 03a03000 moveq r3, #0 <== NOT EXECUTED 3895c: e5853000 str r3, [r5] <== NOT EXECUTED
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
38960: e5962004 ldr r2, [r6, #4] <== NOT EXECUTED 38964: e1530002 cmp r3, r2 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
printf ("rtems-rfs: block-find: invalid block in table:"
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
38968: 23a00000 movcs r0, #0 <== NOT EXECUTED
*result = rtems_rfs_block_get_number (buffer, offset);
if ((*result + 1) == 0)
*result = 0;
if (*result >= rtems_rfs_fs_blocks (fs))
3896c: 33a00000 movcc r0, #0 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_FIND))
printf ("rtems-rfs: block-find: invalid block in table:"
" block=%" PRId32 ", indirect=%" PRId32 "/%d\n", *result, block, offset);
*result = 0;
38970: 25850000 strcs r0, [r5] <== NOT EXECUTED
rc = EIO;
}
return 0;
}
38974: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00038860 <rtems_rfs_block_get_block_size>:
void
rtems_rfs_block_get_block_size (rtems_rfs_file_system* fs,
rtems_rfs_pos pos,
rtems_rfs_block_size* size)
{
38860: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
38864: e1a04002 mov r4, r2 <== NOT EXECUTED
if (pos == 0)
38868: e1912002 orrs r2, r1, r2 <== NOT EXECUTED
void
rtems_rfs_block_get_block_size (rtems_rfs_file_system* fs,
rtems_rfs_pos pos,
rtems_rfs_block_size* size)
{
3886c: e1a05001 mov r5, r1 <== NOT EXECUTED 38870: e1a06003 mov r6, r3 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)
{
size->count = 0;
size->offset = 0;
38874: 05832004 streq r2, [r3, #4] <== NOT EXECUTED
* @param size A pointer to the block size.
*/
static inline void
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)
{
size->count = 0;
38878: 05832000 streq r2, [r3] <== NOT EXECUTED
if (pos == 0)
3887c: 08bd80f0 popeq {r4, r5, r6, r7, pc} <== NOT EXECUTED
rtems_rfs_block_set_size_zero (size);
else
{
size->count = pos / rtems_rfs_fs_block_size (fs) + 1;
38880: e5907008 ldr r7, [r0, #8] <== NOT EXECUTED 38884: e3a03000 mov r3, #0 <== NOT EXECUTED 38888: e1a02007 mov r2, r7 <== NOT EXECUTED 3888c: e1a00001 mov r0, r1 <== NOT EXECUTED 38890: e1a01004 mov r1, r4 <== NOT EXECUTED 38894: eb008d9f bl 5bf18 <__udivdi3> <== NOT EXECUTED 38898: e2800001 add r0, r0, #1 <== NOT EXECUTED 3889c: e5860000 str r0, [r6] <== NOT EXECUTED
size->offset = pos % rtems_rfs_fs_block_size (fs);
388a0: e1a01004 mov r1, r4 <== NOT EXECUTED
388a4: e1a00005 mov r0, r5 <== NOT EXECUTED
388a8: e1a02007 mov r2, r7 <== NOT EXECUTED
388ac: e3a03000 mov r3, #0 <== NOT EXECUTED
388b0: eb008ea9 bl 5c35c <__umoddi3> <== NOT EXECUTED
388b4: e5860004 str r0, [r6, #4] <== NOT EXECUTED
388b8: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00038800 <rtems_rfs_block_get_bpos>:
void
rtems_rfs_block_get_bpos (rtems_rfs_file_system* fs,
rtems_rfs_pos pos,
rtems_rfs_block_pos* bpos)
{
38800: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
bpos->bno = pos / rtems_rfs_fs_block_size (fs);
38804: e5906008 ldr r6, [r0, #8] <== NOT EXECUTED
void
rtems_rfs_block_get_bpos (rtems_rfs_file_system* fs,
rtems_rfs_pos pos,
rtems_rfs_block_pos* bpos)
{
38808: e1a08002 mov r8, r2 <== NOT EXECUTED
bpos->bno = pos / rtems_rfs_fs_block_size (fs);
3880c: e3a05000 mov r5, #0 <== NOT EXECUTED
void
rtems_rfs_block_get_bpos (rtems_rfs_file_system* fs,
rtems_rfs_pos pos,
rtems_rfs_block_pos* bpos)
{
38810: e1a04003 mov r4, r3 <== NOT EXECUTED 38814: e1a07001 mov r7, r1 <== NOT EXECUTED
bpos->bno = pos / rtems_rfs_fs_block_size (fs);
38818: e1a02006 mov r2, r6 <== NOT EXECUTED 3881c: e1a03005 mov r3, r5 <== NOT EXECUTED 38820: e1a00001 mov r0, r1 <== NOT EXECUTED 38824: e1a01008 mov r1, r8 <== NOT EXECUTED 38828: eb008dba bl 5bf18 <__udivdi3> <== NOT EXECUTED
bpos->boff = pos % rtems_rfs_fs_block_size (fs);
3882c: e1a02006 mov r2, r6 <== NOT EXECUTED
void
rtems_rfs_block_get_bpos (rtems_rfs_file_system* fs,
rtems_rfs_pos pos,
rtems_rfs_block_pos* bpos)
{
bpos->bno = pos / rtems_rfs_fs_block_size (fs);
38830: e5840000 str r0, [r4] <== NOT EXECUTED
bpos->boff = pos % rtems_rfs_fs_block_size (fs);
38834: e1a01008 mov r1, r8 <== NOT EXECUTED 38838: e1a00007 mov r0, r7 <== NOT EXECUTED 3883c: e1a03005 mov r3, r5 <== NOT EXECUTED 38840: eb008ec5 bl 5c35c <__umoddi3> <== NOT EXECUTED 38844: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
38848: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
0003884c <rtems_rfs_block_get_pos>:
rtems_rfs_pos
rtems_rfs_block_get_pos (rtems_rfs_file_system* fs,
rtems_rfs_block_pos* bpos)
{
3884c: e5902008 ldr r2, [r0, #8] <== NOT EXECUTED
38850: e8910009 ldm r1, {r0, r3} <== NOT EXECUTED
return (bpos->bno * rtems_rfs_fs_block_size (fs)) + bpos->boff; }
38854: e3a01000 mov r1, #0 <== NOT EXECUTED 38858: e0203092 mla r0, r2, r0, r3 <== NOT EXECUTED 3885c: e12fff1e bx lr <== NOT EXECUTED
000388bc <rtems_rfs_block_get_size>:
rtems_rfs_block_get_size (rtems_rfs_file_system* fs,
rtems_rfs_block_size* size)
{
uint32_t offset;
uint64_t block_size;
if (size->count == 0)
388bc: e5912000 ldr r2, [r1] <== NOT EXECUTED 388c0: e3520000 cmp r2, #0 <== NOT EXECUTED
}
rtems_rfs_pos
rtems_rfs_block_get_size (rtems_rfs_file_system* fs,
rtems_rfs_block_size* size)
{
388c4: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
uint32_t offset; uint64_t block_size; if (size->count == 0)
388c8: 03a03000 moveq r3, #0 <== NOT EXECUTED 388cc: 03a04000 moveq r4, #0 <== NOT EXECUTED 388d0: 0a000007 beq 388f4 <rtems_rfs_block_get_size+0x38> <== NOT EXECUTED
return 0;
if (size->offset == 0)
388d4: e5913004 ldr r3, [r1, #4] <== NOT EXECUTED 388d8: e3530000 cmp r3, #0 <== NOT EXECUTED
offset = rtems_rfs_fs_block_size (fs);
388dc: 05903008 ldreq r3, [r0, #8] <== NOT EXECUTED
{
uint32_t offset;
uint64_t block_size;
if (size->count == 0)
return 0;
if (size->offset == 0)
388e0: 15901008 ldrne r1, [r0, #8] <== NOT EXECUTED
offset = rtems_rfs_fs_block_size (fs);
388e4: 01a01003 moveq r1, r3 <== NOT EXECUTED
else
offset = size->offset;
block_size = rtems_rfs_fs_block_size (fs);
return (((uint64_t) (size->count - 1)) * block_size) + offset;
388e8: e2422001 sub r2, r2, #1 <== NOT EXECUTED 388ec: e3a04000 mov r4, #0 <== NOT EXECUTED 388f0: e0a43192 umlal r3, r4, r2, r1 <== NOT EXECUTED
}
388f4: e1a01004 mov r1, r4 <== NOT EXECUTED
388f8: e1a00003 mov r0, r3 <== NOT EXECUTED
388fc: e8bd0010 pop {r4} <== NOT EXECUTED
38900: e12fff1e bx lr <== NOT EXECUTED
00039434 <rtems_rfs_block_map_close>:
rtems_rfs_block_map* map)
{
int rc = 0;
int brc;
if (map->dirty && map->inode)
39434: e5d13000 ldrb r3, [r1] <== NOT EXECUTED 39438: e3530000 cmp r3, #0 <== NOT EXECUTED
}
int
rtems_rfs_block_map_close (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
3943c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
39440: e1a04001 mov r4, r1 <== NOT EXECUTED
39444: e1a05000 mov r5, r0 <== NOT EXECUTED
int rc = 0;
int brc;
if (map->dirty && map->inode)
39448: 0a000015 beq 394a4 <rtems_rfs_block_map_close+0x70> <== NOT EXECUTED 3944c: e5911004 ldr r1, [r1, #4] <== NOT EXECUTED 39450: e3510000 cmp r1, #0 <== NOT EXECUTED 39454: 0a000012 beq 394a4 <rtems_rfs_block_map_close+0x70> <== NOT EXECUTED
{
brc = rtems_rfs_inode_load (fs, map->inode);
39458: eb000f69 bl 3d204 <rtems_rfs_inode_load> <== NOT EXECUTED
if (brc > 0)
3945c: e2507000 subs r7, r0, #0 <== NOT EXECUTED 39460: da000011 ble 394ac <rtems_rfs_block_map_close+0x78> <== NOT EXECUTED
map->dirty = false;
}
}
map->inode = NULL;
39464: e3a06000 mov r6, #0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
39468: e2841038 add r1, r4, #56 ; 0x38 <== NOT EXECUTED 3946c: e5846004 str r6, [r4, #4] <== NOT EXECUTED 39470: e1a00005 mov r0, r5 <== NOT EXECUTED 39474: eb00012c bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
39478: e5c46038 strb r6, [r4, #56] ; 0x38 <== NOT EXECUTED
handle->bnum = 0;
3947c: e584603c str r6, [r4, #60] ; 0x3c <== NOT EXECUTED
handle->buffer = NULL;
39480: e5846040 str r6, [r4, #64] ; 0x40 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
39484: e1a00005 mov r0, r5 <== NOT EXECUTED 39488: e2841044 add r1, r4, #68 ; 0x44 <== NOT EXECUTED 3948c: eb000126 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false; handle->bnum = 0; handle->buffer = NULL;
39490: e584604c str r6, [r4, #76] ; 0x4c <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
39494: e5c46044 strb r6, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
39498: e5846048 str r6, [r4, #72] ; 0x48 <== NOT EXECUTED
rc = brc;
brc = rtems_rfs_buffer_handle_close (fs, &map->doubly_buffer);
if ((brc > 0) && (rc == 0))
rc = brc;
return rc;
}
3949c: e1a00007 mov r0, r7 <== NOT EXECUTED
394a0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
brc = rtems_rfs_inode_unload (fs, map->inode, true);
if (brc > 0)
rc = brc;
map->dirty = false;
394a4: e3a07000 mov r7, #0 <== NOT EXECUTED 394a8: eaffffed b 39464 <rtems_rfs_block_map_close+0x30> <== NOT EXECUTED
int brc;
if (map->dirty && map->inode)
{
brc = rtems_rfs_inode_load (fs, map->inode);
if (brc > 0)
394ac: e1a00004 mov r0, r4 <== NOT EXECUTED 394b0: e3a03000 mov r3, #0 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
394b4: e3a06001 mov r6, #1 <== NOT EXECUTED
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
394b8: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED 394bc: e5901024 ldr r1, [r0, #36] ; 0x24 <== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
394c0: e592c00c ldr ip, [r2, #12] <== NOT EXECUTED 394c4: e1a0ec21 lsr lr, r1, #24 <== NOT EXECUTED 394c8: e08cc003 add ip, ip, r3 <== NOT EXECUTED 394cc: e5cce01c strb lr, [ip, #28] <== NOT EXECUTED 394d0: e592c00c ldr ip, [r2, #12] <== NOT EXECUTED 394d4: e1a0e821 lsr lr, r1, #16 <== NOT EXECUTED 394d8: e08cc003 add ip, ip, r3 <== NOT EXECUTED 394dc: e5cce01d strb lr, [ip, #29] <== NOT EXECUTED 394e0: e592c00c ldr ip, [r2, #12] <== NOT EXECUTED 394e4: e1a0e421 lsr lr, r1, #8 <== NOT EXECUTED 394e8: e08cc003 add ip, ip, r3 <== NOT EXECUTED 394ec: e5cce01e strb lr, [ip, #30] <== NOT EXECUTED 394f0: e592c00c ldr ip, [r2, #12] <== NOT EXECUTED 394f4: e08cc003 add ip, ip, r3 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
394f8: e2833004 add r3, r3, #4 <== NOT EXECUTED
if (rc == 0)
{
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
394fc: e3530014 cmp r3, #20 <== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
39500: e5cc101f strb r1, [ip, #31] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
39504: e2800004 add r0, r0, #4 <== NOT EXECUTED 39508: e5c26010 strb r6, [r2, #16] <== NOT EXECUTED 3950c: e3a02001 mov r2, #1 <== NOT EXECUTED 39510: 1affffe8 bne 394b8 <rtems_rfs_block_map_close+0x84> <== NOT EXECUTED
rtems_rfs_inode_set_block (map->inode, b, map->blocks[b]);
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
39514: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 39518: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
3951c: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 39520: e1a0cc21 lsr ip, r1, #24 <== NOT EXECUTED 39524: e5c0c00c strb ip, [r0, #12] <== NOT EXECUTED 39528: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 3952c: e1a0c821 lsr ip, r1, #16 <== NOT EXECUTED 39530: e5c0c00d strb ip, [r0, #13] <== NOT EXECUTED 39534: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 39538: e1a0c421 lsr ip, r1, #8 <== NOT EXECUTED 3953c: e5c0c00e strb ip, [r0, #14] <== NOT EXECUTED 39540: e593000c ldr r0, [r3, #12] <== NOT EXECUTED 39544: e5c0100f strb r1, [r0, #15] <== NOT EXECUTED
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
39548: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 3954c: e594100c ldr r1, [r4, #12] <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
39550: e590c00c ldr ip, [r0, #12] <== NOT EXECUTED 39554: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 39558: e1a0ec21 lsr lr, r1, #24 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3955c: e5c32010 strb r2, [r3, #16] <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
39560: e5cce00a strb lr, [ip, #10] <== NOT EXECUTED 39564: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 39568: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 3956c: e5c3100b strb r1, [r3, #11] <== NOT EXECUTED
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
39570: e5941004 ldr r1, [r4, #4] <== NOT EXECUTED 39574: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
* @param block_count The last map block number.
*/
static inline void
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
39578: e591c00c ldr ip, [r1, #12] <== NOT EXECUTED 3957c: e1a0ec23 lsr lr, r3, #24 <== NOT EXECUTED
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
39580: e5c02010 strb r2, [r0, #16] <== NOT EXECUTED
* @param block_count The last map block number.
*/
static inline void
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
39584: e5cce030 strb lr, [ip, #48] ; 0x30 <== NOT EXECUTED 39588: e591000c ldr r0, [r1, #12] <== NOT EXECUTED 3958c: e1a0c823 lsr ip, r3, #16 <== NOT EXECUTED 39590: e5c0c031 strb ip, [r0, #49] ; 0x31 <== NOT EXECUTED 39594: e591000c ldr r0, [r1, #12] <== NOT EXECUTED 39598: e1a0c423 lsr ip, r3, #8 <== NOT EXECUTED 3959c: e5c0c032 strb ip, [r0, #50] ; 0x32 <== NOT EXECUTED 395a0: e591000c ldr r0, [r1, #12] <== NOT EXECUTED 395a4: e5c03033 strb r3, [r0, #51] ; 0x33 <== NOT EXECUTED
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
395a8: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED 395ac: e5940020 ldr r0, [r4, #32] <== NOT EXECUTED
* @param block_count The last data block number.
*/
static inline void
rtems_rfs_inode_set_last_data_block (rtems_rfs_inode_handle* handle, uint32_t last_data_block)
{
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
395b0: e593c00c ldr ip, [r3, #12] <== NOT EXECUTED 395b4: e1a0ec20 lsr lr, r0, #24 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
395b8: e5c12010 strb r2, [r1, #16] <== NOT EXECUTED
* @param block_count The last data block number.
*/
static inline void
rtems_rfs_inode_set_last_data_block (rtems_rfs_inode_handle* handle, uint32_t last_data_block)
{
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
395bc: e5cce034 strb lr, [ip, #52] ; 0x34 <== NOT EXECUTED 395c0: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 395c4: e1a0c820 lsr ip, r0, #16 <== NOT EXECUTED 395c8: e5c1c035 strb ip, [r1, #53] ; 0x35 <== NOT EXECUTED 395cc: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 395d0: e1a0c420 lsr ip, r0, #8 <== NOT EXECUTED 395d4: e5c1c036 strb ip, [r1, #54] ; 0x36 <== NOT EXECUTED 395d8: e593100c ldr r1, [r3, #12] <== NOT EXECUTED 395dc: e5c10037 strb r0, [r1, #55] ; 0x37 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
395e0: e5c32010 strb r2, [r3, #16] <== NOT EXECUTED
brc = rtems_rfs_inode_unload (fs, map->inode, true);
395e4: e1a00005 mov r0, r5 <== NOT EXECUTED 395e8: e5941004 ldr r1, [r4, #4] <== NOT EXECUTED 395ec: eb000ecd bl 3d128 <rtems_rfs_inode_unload> <== NOT EXECUTED
if (brc > 0)
rc = brc;
map->dirty = false;
395f0: e3a03000 mov r3, #0 <== NOT EXECUTED 395f4: e5c43000 strb r3, [r4] <== NOT EXECUTED
rtems_rfs_inode_set_block_count (map->inode, map->size.count);
rtems_rfs_inode_set_block_offset (map->inode, map->size.offset);
rtems_rfs_inode_set_last_map_block (map->inode, map->last_map_block);
rtems_rfs_inode_set_last_data_block (map->inode, map->last_data_block);
brc = rtems_rfs_inode_unload (fs, map->inode, true);
395f8: e1c07fc0 bic r7, r0, r0, asr #31 <== NOT EXECUTED 395fc: eaffff98 b 39464 <rtems_rfs_block_map_close+0x30> <== NOT EXECUTED
00038978 <rtems_rfs_block_map_find>:
int
rtems_rfs_block_map_find (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_block_pos* bpos,
rtems_rfs_block_no* block)
{
38978: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3897c: e1a06003 mov r6, r3 <== NOT EXECUTED
int rc = 0;
*block = 0;
38980: e3a03000 mov r3, #0 <== NOT EXECUTED 38984: e5863000 str r3, [r6] <== NOT EXECUTED
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
38988: e592b000 ldr fp, [r2] <== NOT EXECUTED 3898c: e15b0003 cmp fp, r3 <== NOT EXECUTED
int
rtems_rfs_block_map_find (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_block_pos* bpos,
rtems_rfs_block_no* block)
{
38990: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 38994: e1a05002 mov r5, r2 <== NOT EXECUTED 38998: e1a07000 mov r7, r0 <== NOT EXECUTED 3899c: e1a04001 mov r4, r1 <== NOT EXECUTED
*block = 0;
/*
* Range checking here makes the remaining logic simpler.
*/
if (rtems_rfs_block_pos_block_past_end (bpos, &map->size))
389a0: 0591a008 ldreq sl, [r1, #8] <== NOT EXECUTED 389a4: 0a000002 beq 389b4 <rtems_rfs_block_map_find+0x3c> <== NOT EXECUTED 389a8: e591a008 ldr sl, [r1, #8] <== NOT EXECUTED 389ac: e35a0000 cmp sl, #0 <== NOT EXECUTED 389b0: 0a000022 beq 38a40 <rtems_rfs_block_map_find+0xc8> <== NOT EXECUTED 389b4: e15b000a cmp fp, sl <== NOT EXECUTED 389b8: 2a000020 bcs 38a40 <rtems_rfs_block_map_find+0xc8> <== NOT EXECUTED
return ENXIO;
/*
* If the block position is the same and we have found the block just return it.
*/
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
389bc: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED 389c0: e15b0003 cmp fp, r3 <== NOT EXECUTED 389c4: 0a000020 beq 38a4c <rtems_rfs_block_map_find+0xd4> <== NOT EXECUTED
/*
* Determine the type of access we need to perform. If the number of blocks
* is less than or equal to the number of slots in the inode the blocks are
* directly accessed.
*/
if (map->size.count <= RTEMS_RFS_INODE_BLOCKS)
389c8: e35a0005 cmp sl, #5 <== NOT EXECUTED 389cc: 8a00000b bhi 38a00 <rtems_rfs_block_map_find+0x88> <== NOT EXECUTED
{
*block = map->blocks[bpos->bno];
389d0: e28bb009 add fp, fp, #9 <== NOT EXECUTED 389d4: e794310b ldr r3, [r4, fp, lsl #2] <== NOT EXECUTED 389d8: e5863000 str r3, [r6] <== NOT EXECUTED
}
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
389dc: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED
389e0: e895000c ldm r5, {r2, r3} <== NOT EXECUTED
389e4: e5841018 str r1, [r4, #24] <== NOT EXECUTED
389e8: e5842010 str r2, [r4, #16] <== NOT EXECUTED
389ec: e5843014 str r3, [r4, #20] <== NOT EXECUTED
map->bpos.block = *block;
389f0: e5963000 ldr r3, [r6] <== NOT EXECUTED 389f4: e3a00000 mov r0, #0 <== NOT EXECUTED 389f8: e5843018 str r3, [r4, #24] <== NOT EXECUTED 389fc: ea000010 b 38a44 <rtems_rfs_block_map_find+0xcc> <== NOT EXECUTED
* The map is either singly or doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
38a00: e5979030 ldr r9, [r7, #48] ; 0x30 <== NOT EXECUTED 38a04: e1a0000b mov r0, fp <== NOT EXECUTED 38a08: e1a01009 mov r1, r9 <== NOT EXECUTED 38a0c: eb0089c9 bl 5b138 <__umodsi3> <== NOT EXECUTED
singly = bpos->bno / fs->blocks_per_block;
38a10: e1a01009 mov r1, r9 <== NOT EXECUTED
* The map is either singly or doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
38a14: e1a08000 mov r8, r0 <== NOT EXECUTED
singly = bpos->bno / fs->blocks_per_block;
38a18: e1a0000b mov r0, fp <== NOT EXECUTED 38a1c: eb008931 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
if (map->size.count <= fs->block_map_singly_blocks)
38a20: e5973034 ldr r3, [r7, #52] ; 0x34 <== NOT EXECUTED 38a24: e15a0003 cmp sl, r3 <== NOT EXECUTED
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = bpos->bno % fs->blocks_per_block;
singly = bpos->bno / fs->blocks_per_block;
38a28: e1a0b000 mov fp, r0 <== NOT EXECUTED 38a2c: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
if (map->size.count <= fs->block_map_singly_blocks)
38a30: 9a000009 bls 38a5c <rtems_rfs_block_map_find+0xe4> <== NOT EXECUTED
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
if (map->size.count < fs->block_map_doubly_blocks)
38a34: e5973038 ldr r3, [r7, #56] ; 0x38 <== NOT EXECUTED 38a38: e15a0003 cmp sl, r3 <== NOT EXECUTED 38a3c: 3a000010 bcc 38a84 <rtems_rfs_block_map_find+0x10c> <== NOT EXECUTED
}
if (rc == 0)
{
rtems_rfs_block_copy_bpos (&map->bpos, bpos);
map->bpos.block = *block;
38a40: e3a00006 mov r0, #6 <== NOT EXECUTED
}
return rc;
}
38a44: e28dd008 add sp, sp, #8 <== NOT EXECUTED
38a48: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
return ENXIO;
/*
* If the block position is the same and we have found the block just return it.
*/
if ((bpos->bno == map->bpos.bno) && (map->bpos.block != 0))
38a4c: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED 38a50: e3530000 cmp r3, #0 <== NOT EXECUTED 38a54: 0affffdb beq 389c8 <rtems_rfs_block_map_find+0x50> <== NOT EXECUTED 38a58: eaffffde b 389d8 <rtems_rfs_block_map_find+0x60> <== NOT EXECUTED
{
/*
* This is a single indirect table of blocks anchored off a slot in the
* inode.
*/
rc = rtems_rfs_block_find_indirect (fs,
38a5c: e280b009 add fp, r0, #9 <== NOT EXECUTED 38a60: e794210b ldr r2, [r4, fp, lsl #2] <== NOT EXECUTED 38a64: e1a00007 mov r0, r7 <== NOT EXECUTED 38a68: e1a03008 mov r3, r8 <== NOT EXECUTED 38a6c: e2841038 add r1, r4, #56 ; 0x38 <== NOT EXECUTED 38a70: e58d6000 str r6, [sp] <== NOT EXECUTED 38a74: ebffffa2 bl 38904 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
}
}
}
}
if (rc == 0)
38a78: e3500000 cmp r0, #0 <== NOT EXECUTED 38a7c: 1afffff0 bne 38a44 <rtems_rfs_block_map_find+0xcc> <== NOT EXECUTED 38a80: eaffffd5 b 389dc <rtems_rfs_block_map_find+0x64> <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
38a84: e1a01009 mov r1, r9 <== NOT EXECUTED 38a88: eb0089aa bl 5b138 <__umodsi3> <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
{
rc = rtems_rfs_block_find_indirect (fs,
38a8c: e1a01009 mov r1, r9 <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
38a90: e1a0a000 mov sl, r0 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
{
rc = rtems_rfs_block_find_indirect (fs,
38a94: e1a0000b mov r0, fp <== NOT EXECUTED 38a98: eb008912 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
38a9c: e28dc008 add ip, sp, #8 <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
{
rc = rtems_rfs_block_find_indirect (fs,
38aa0: e2800009 add r0, r0, #9 <== NOT EXECUTED 38aa4: e7942100 ldr r2, [r4, r0, lsl #2] <== NOT EXECUTED
* The map is doubly indirect.
*/
rtems_rfs_block_no doubly;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
38aa8: e52ca004 str sl, [ip, #-4]! <== NOT EXECUTED
if (map->size.count < fs->block_map_doubly_blocks)
{
rc = rtems_rfs_block_find_indirect (fs,
38aac: e1a0300a mov r3, sl <== NOT EXECUTED 38ab0: e1a00007 mov r0, r7 <== NOT EXECUTED 38ab4: e2841044 add r1, r4, #68 ; 0x44 <== NOT EXECUTED 38ab8: e58dc000 str ip, [sp] <== NOT EXECUTED 38abc: ebffff90 bl 38904 <rtems_rfs_block_find_indirect> <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
singly, &singly);
if (rc == 0)
38ac0: e3500000 cmp r0, #0 <== NOT EXECUTED 38ac4: 1affffde bne 38a44 <rtems_rfs_block_map_find+0xcc> <== NOT EXECUTED
{
rc = rtems_rfs_block_find_indirect (fs,
38ac8: e1a00007 mov r0, r7 <== NOT EXECUTED 38acc: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 38ad0: e1a03008 mov r3, r8 <== NOT EXECUTED 38ad4: e2841038 add r1, r4, #56 ; 0x38 <== NOT EXECUTED 38ad8: e58d6000 str r6, [sp] <== NOT EXECUTED 38adc: ebffff88 bl 38904 <rtems_rfs_block_find_indirect> <== NOT EXECUTED 38ae0: eaffffe4 b 38a78 <rtems_rfs_block_map_find+0x100> <== NOT EXECUTED
00038f18 <rtems_rfs_block_map_free_all>:
int
rtems_rfs_block_map_free_all (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map)
{
return rtems_rfs_block_map_shrink (fs, map, map->size.count);
38f18: e5912008 ldr r2, [r1, #8] <== NOT EXECUTED 38f1c: eaffff45 b 38c38 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
00039050 <rtems_rfs_block_map_grow>:
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks,
rtems_rfs_block_no* new_block)
{
39050: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
39054: e24dd01c sub sp, sp, #28 <== NOT EXECUTED
39058: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
3905c: e1a04001 mov r4, r1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
39060: e5902038 ldr r2, [r0, #56] ; 0x38 <== NOT EXECUTED
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks,
rtems_rfs_block_no* new_block)
{
39064: e1a06000 mov r6, r0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
39068: e5911008 ldr r1, [r1, #8] <== NOT EXECUTED 3906c: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 39070: e0801001 add r1, r0, r1 <== NOT EXECUTED 39074: e1510002 cmp r1, r2 <== NOT EXECUTED
int
rtems_rfs_block_map_grow (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks,
rtems_rfs_block_no* new_block)
{
39078: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if ((map->size.count + blocks) >= rtems_rfs_fs_max_block_map_blocks (fs))
3907c: 23a0a01b movcs sl, #27 <== NOT EXECUTED 39080: 2a0000bb bcs 39374 <rtems_rfs_block_map_grow+0x324> <== NOT EXECUTED
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
39084: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 39088: e3520000 cmp r2, #0 <== NOT EXECUTED 3908c: 0a0000d4 beq 393e4 <rtems_rfs_block_map_grow+0x394> <== NOT EXECUTED
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
39090: e2843038 add r3, r4, #56 ; 0x38 <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
39094: e2840044 add r0, r4, #68 ; 0x44 <== NOT EXECUTED 39098: e3a05000 mov r5, #0 <== NOT EXECUTED
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
3909c: e5941020 ldr r1, [r4, #32] <== NOT EXECUTED
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
390a0: e58d300c str r3, [sp, #12] <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
390a4: e58d0010 str r0, [sp, #16] <== NOT EXECUTED
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
390a8: e3a08001 mov r8, #1 <== NOT EXECUTED 390ac: ea000011 b 390f8 <rtems_rfs_block_map_grow+0xa8> <== NOT EXECUTED
false, &block);
if (rc > 0)
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
map->blocks[map->size.count] = block;
390b0: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED 390b4: e28a3009 add r3, sl, #9 <== NOT EXECUTED 390b8: e7841103 str r1, [r4, r3, lsl #2] <== NOT EXECUTED 390bc: e1a03001 mov r3, r1 <== NOT EXECUTED
}
map->size.count++;
map->size.offset = 0;
if (b == 0)
390c0: e3550000 cmp r5, #0 <== NOT EXECUTED
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
map->size.offset = 0;
390c4: e3a02000 mov r2, #0 <== NOT EXECUTED 390c8: e584200c str r2, [r4, #12] <== NOT EXECUTED
if (b == 0)
*new_block = block;
390cc: 059d0008 ldreq r0, [sp, #8] <== NOT EXECUTED
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
390d0: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
390d4: e28aa001 add sl, sl, #1 <== NOT EXECUTED
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
390d8: e2855001 add r5, r5, #1 <== NOT EXECUTED
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
}
map->size.count++;
390dc: e584a008 str sl, [r4, #8] <== NOT EXECUTED
map->size.offset = 0;
if (b == 0)
*new_block = block;
390e0: 01a01003 moveq r1, r3 <== NOT EXECUTED 390e4: 05803000 streq r3, [r0] <== NOT EXECUTED
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
390e8: e1520005 cmp r2, r5 <== NOT EXECUTED
map->size.count++;
map->size.offset = 0;
if (b == 0)
*new_block = block;
map->last_data_block = block;
390ec: e5843020 str r3, [r4, #32] <== NOT EXECUTED
map->dirty = true;
390f0: e5c48000 strb r8, [r4] <== NOT EXECUTED
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
390f4: 9a0000ba bls 393e4 <rtems_rfs_block_map_grow+0x394> <== NOT EXECUTED
/*
* Allocate the block. If an indirect block is needed and cannot be
* allocated free this block.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_data_block,
390f8: e1a00006 mov r0, r6 <== NOT EXECUTED 390fc: e3a02000 mov r2, #0 <== NOT EXECUTED 39100: e28d3018 add r3, sp, #24 <== NOT EXECUTED 39104: eb000e8e bl 3cb44 <rtems_rfs_group_bitmap_alloc> <== NOT EXECUTED
false, &block);
if (rc > 0)
39108: e3500000 cmp r0, #0 <== NOT EXECUTED 3910c: ca0000b6 bgt 393ec <rtems_rfs_block_map_grow+0x39c> <== NOT EXECUTED
return rc;
if (map->size.count < RTEMS_RFS_INODE_BLOCKS)
39110: e594a008 ldr sl, [r4, #8] <== NOT EXECUTED 39114: e35a0004 cmp sl, #4 <== NOT EXECUTED 39118: 9affffe4 bls 390b0 <rtems_rfs_block_map_grow+0x60> <== NOT EXECUTED
* Single indirect access is occuring. It could still be doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = map->size.count % fs->blocks_per_block;
3911c: e5969030 ldr r9, [r6, #48] ; 0x30 <== NOT EXECUTED 39120: e1a0000a mov r0, sl <== NOT EXECUTED 39124: e1a01009 mov r1, r9 <== NOT EXECUTED 39128: eb008802 bl 5b138 <__umodsi3> <== NOT EXECUTED
singly = map->size.count / fs->blocks_per_block;
3912c: e1a01009 mov r1, r9 <== NOT EXECUTED
* Single indirect access is occuring. It could still be doubly indirect.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = map->size.count % fs->blocks_per_block;
39130: e1a07000 mov r7, r0 <== NOT EXECUTED
singly = map->size.count / fs->blocks_per_block;
39134: e1a0000a mov r0, sl <== NOT EXECUTED 39138: eb00876a bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
if (map->size.count < fs->block_map_singly_blocks)
3913c: e5963034 ldr r3, [r6, #52] ; 0x34 <== NOT EXECUTED 39140: e15a0003 cmp sl, r3 <== NOT EXECUTED
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = map->size.count % fs->blocks_per_block;
singly = map->size.count / fs->blocks_per_block;
39144: e1a0b000 mov fp, r0 <== NOT EXECUTED
if (map->size.count < fs->block_map_singly_blocks)
39148: 2a00002b bcs 391fc <rtems_rfs_block_map_grow+0x1ac> <== NOT EXECUTED
* Singly indirect tables are being used. Allocate a new block for a
* mapping table if direct is 0 or we are moving up (upping). If upping
* move the direct blocks into the table and if not this is the first
* entry of a new block.
*/
if ((direct == 0) ||
3914c: e3570000 cmp r7, #0 <== NOT EXECUTED 39150: 0a000002 beq 39160 <rtems_rfs_block_map_grow+0x110> <== NOT EXECUTED 39154: e3570005 cmp r7, #5 <== NOT EXECUTED 39158: 03500000 cmpeq r0, #0 <== NOT EXECUTED 3915c: 1a000087 bne 39380 <rtems_rfs_block_map_grow+0x330> <== NOT EXECUTED
/*
* Upping is when we move from direct to singly indirect.
*/
bool upping;
upping = map->size.count == RTEMS_RFS_INODE_BLOCKS;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
39160: e28b3009 add r3, fp, #9 <== NOT EXECUTED 39164: e35a0005 cmp sl, #5 <== NOT EXECUTED 39168: 13a0c000 movne ip, #0 <== NOT EXECUTED 3916c: 03a0c001 moveq ip, #1 <== NOT EXECUTED 39170: e0843103 add r3, r4, r3, lsl #2 <== NOT EXECUTED 39174: e1a00006 mov r0, r6 <== NOT EXECUTED 39178: e1a01004 mov r1, r4 <== NOT EXECUTED 3917c: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 39180: e58dc000 str ip, [sp] <== NOT EXECUTED 39184: ebffff65 bl 38f20 <rtems_rfs_block_map_indirect_alloc> <== NOT EXECUTED
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
}
if (rc > 0)
39188: e3500000 cmp r0, #0 <== NOT EXECUTED 3918c: ca000073 bgt 39360 <rtems_rfs_block_map_grow+0x310> <== NOT EXECUTED
return rc;
}
}
}
rtems_rfs_block_set_number (&map->singly_buffer, direct, block);
39190: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED 39194: e5dd201b ldrb r2, [sp, #27] <== NOT EXECUTED 39198: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 3919c: e7c32107 strb r2, [r3, r7, lsl #2] <== NOT EXECUTED 391a0: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED 391a4: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED 391a8: e1dd11ba ldrh r1, [sp, #26] <== NOT EXECUTED 391ac: e1a03107 lsl r3, r7, #2 <== NOT EXECUTED 391b0: e0822003 add r2, r2, r3 <== NOT EXECUTED 391b4: e5c21001 strb r1, [r2, #1] <== NOT EXECUTED 391b8: e5942040 ldr r2, [r4, #64] ; 0x40 <== NOT EXECUTED 391bc: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED 391c0: e5922020 ldr r2, [r2, #32] <== NOT EXECUTED 391c4: e1a07087 lsl r7, r7, #1 <== NOT EXECUTED 391c8: e1a01421 lsr r1, r1, #8 <== NOT EXECUTED 391cc: e2877001 add r7, r7, #1 <== NOT EXECUTED 391d0: e7c21087 strb r1, [r2, r7, lsl #1] <== NOT EXECUTED 391d4: e5942040 ldr r2, [r4, #64] ; 0x40 <== NOT EXECUTED 391d8: e5922020 ldr r2, [r2, #32] <== NOT EXECUTED 391dc: e0823003 add r3, r2, r3 <== NOT EXECUTED 391e0: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 391e4: e5c32003 strb r2, [r3, #3] <== NOT EXECUTED 391e8: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 391ec: e5c48038 strb r8, [r4, #56] ; 0x38 <== NOT EXECUTED 391f0: e594a008 ldr sl, [r4, #8] <== NOT EXECUTED 391f4: e1a01003 mov r1, r3 <== NOT EXECUTED 391f8: eaffffb0 b 390c0 <rtems_rfs_block_map_grow+0x70> <== NOT EXECUTED
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
391fc: e1a01009 mov r1, r9 <== NOT EXECUTED 39200: eb008738 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
singly %= fs->blocks_per_block;
39204: e1a01009 mov r1, r9 <== NOT EXECUTED
* Doubly indirect tables are being used.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
39208: e1a0a000 mov sl, r0 <== NOT EXECUTED
singly %= fs->blocks_per_block;
3920c: e1a0000b mov r0, fp <== NOT EXECUTED 39210: eb0087c8 bl 5b138 <__umodsi3> <== NOT EXECUTED
* Allocate a new block for a singly indirect table if direct is 0 as
* it is the first entry of a new block. We may also need to allocate a
* doubly indirect block as well. Both always occur when direct is 0
* and the doubly indirect block when singly is 0.
*/
if (direct == 0)
39214: e3570000 cmp r7, #0 <== NOT EXECUTED
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no singly_block;
doubly = singly / fs->blocks_per_block;
singly %= fs->blocks_per_block;
39218: e1a09000 mov r9, r0 <== NOT EXECUTED
* Allocate a new block for a singly indirect table if direct is 0 as
* it is the first entry of a new block. We may also need to allocate a
* doubly indirect block as well. Both always occur when direct is 0
* and the doubly indirect block when singly is 0.
*/
if (direct == 0)
3921c: 1a000034 bne 392f4 <rtems_rfs_block_map_grow+0x2a4> <== NOT EXECUTED
{
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
39220: e1a00006 mov r0, r6 <== NOT EXECUTED 39224: e1a01004 mov r1, r4 <== NOT EXECUTED 39228: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 3922c: e28d3014 add r3, sp, #20 <== NOT EXECUTED 39230: e58d7000 str r7, [sp] <== NOT EXECUTED 39234: ebffff39 bl 38f20 <rtems_rfs_block_map_indirect_alloc> <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
39238: e3500000 cmp r0, #0 <== NOT EXECUTED 3923c: ca00006c bgt 393f4 <rtems_rfs_block_map_grow+0x3a4> <== NOT EXECUTED
/*
* Allocate a new block for a doubly indirect table if singly is 0 as
* it is the first entry of a new singly indirect block.
*/
if ((singly == 0) ||
39240: e3590000 cmp r9, #0 <== NOT EXECUTED 39244: 0a000004 beq 3925c <rtems_rfs_block_map_grow+0x20c> <== NOT EXECUTED 39248: e3590005 cmp r9, #5 <== NOT EXECUTED 3924c: 035a0000 cmpeq sl, #0 <== NOT EXECUTED 39250: 13a0b000 movne fp, #0 <== NOT EXECUTED 39254: 03a0b001 moveq fp, #1 <== NOT EXECUTED 39258: 1a00004f bne 3939c <rtems_rfs_block_map_grow+0x34c> <== NOT EXECUTED
((doubly == 0) && (singly == RTEMS_RFS_INODE_BLOCKS)))
{
bool upping;
upping = map->size.count == fs->block_map_singly_blocks;
rc = rtems_rfs_block_map_indirect_alloc (fs, map,
3925c: e5962034 ldr r2, [r6, #52] ; 0x34 <== NOT EXECUTED 39260: e594c008 ldr ip, [r4, #8] <== NOT EXECUTED 39264: e28a3009 add r3, sl, #9 <== NOT EXECUTED 39268: e15c0002 cmp ip, r2 <== NOT EXECUTED 3926c: 13a0c000 movne ip, #0 <== NOT EXECUTED 39270: 03a0c001 moveq ip, #1 <== NOT EXECUTED 39274: e0843103 add r3, r4, r3, lsl #2 <== NOT EXECUTED 39278: e1a00006 mov r0, r6 <== NOT EXECUTED 3927c: e1a01004 mov r1, r4 <== NOT EXECUTED 39280: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 39284: e58dc000 str ip, [sp] <== NOT EXECUTED 39288: ebffff24 bl 38f20 <rtems_rfs_block_map_indirect_alloc> <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
upping);
if (rc > 0)
3928c: e3500000 cmp r0, #0 <== NOT EXECUTED 39290: ca00005d bgt 3940c <rtems_rfs_block_map_grow+0x3bc> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
}
rtems_rfs_block_set_number (&map->doubly_buffer,
39294: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED 39298: e5dd2017 ldrb r2, [sp, #23] <== NOT EXECUTED 3929c: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 392a0: e7c32109 strb r2, [r3, r9, lsl #2] <== NOT EXECUTED 392a4: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED 392a8: e5932020 ldr r2, [r3, #32] <== NOT EXECUTED 392ac: e1dd11b6 ldrh r1, [sp, #22] <== NOT EXECUTED 392b0: e1a03109 lsl r3, r9, #2 <== NOT EXECUTED 392b4: e0822003 add r2, r2, r3 <== NOT EXECUTED 392b8: e5c21001 strb r1, [r2, #1] <== NOT EXECUTED 392bc: e594204c ldr r2, [r4, #76] ; 0x4c <== NOT EXECUTED 392c0: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 392c4: e5922020 ldr r2, [r2, #32] <== NOT EXECUTED 392c8: e1a09089 lsl r9, r9, #1 <== NOT EXECUTED 392cc: e2899001 add r9, r9, #1 <== NOT EXECUTED 392d0: e1a01421 lsr r1, r1, #8 <== NOT EXECUTED 392d4: e7c21089 strb r1, [r2, r9, lsl #1] <== NOT EXECUTED 392d8: e594204c ldr r2, [r4, #76] ; 0x4c <== NOT EXECUTED 392dc: e5922020 ldr r2, [r2, #32] <== NOT EXECUTED 392e0: e0823003 add r3, r2, r3 <== NOT EXECUTED 392e4: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 392e8: e5c32003 strb r2, [r3, #3] <== NOT EXECUTED 392ec: e5c48044 strb r8, [r4, #68] ; 0x44 <== NOT EXECUTED 392f0: eaffffa6 b 39190 <rtems_rfs_block_map_grow+0x140> <== NOT EXECUTED
singly,
singly_block);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs,
392f4: e28aa009 add sl, sl, #9 <== NOT EXECUTED 392f8: e794210a ldr r2, [r4, sl, lsl #2] <== NOT EXECUTED 392fc: e1a00006 mov r0, r6 <== NOT EXECUTED 39300: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 39304: e3a03001 mov r3, #1 <== NOT EXECUTED 39308: eb0001d1 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
&map->doubly_buffer,
map->blocks[doubly],
true);
if (rc > 0)
3930c: e3500000 cmp r0, #0 <== NOT EXECUTED 39310: ca000012 bgt 39360 <rtems_rfs_block_map_grow+0x310> <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
39314: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED 39318: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 3931c: e0832109 add r2, r3, r9, lsl #2 <== NOT EXECUTED 39320: e7d30109 ldrb r0, [r3, r9, lsl #2] <== NOT EXECUTED 39324: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED 39328: e1a09002 mov r9, r2 <== NOT EXECUTED 3932c: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED 39330: e5d93002 ldrb r3, [r9, #2] <== NOT EXECUTED 39334: e181cc00 orr ip, r1, r0, lsl #24 <== NOT EXECUTED 39338: e18cc802 orr ip, ip, r2, lsl #16 <== NOT EXECUTED 3933c: e18cc403 orr ip, ip, r3, lsl #8 <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
39340: e1a0200c mov r2, ip <== NOT EXECUTED 39344: e1a00006 mov r0, r6 <== NOT EXECUTED 39348: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 3934c: e3a03001 mov r3, #1 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
return rc;
}
singly_block = rtems_rfs_block_get_number (&map->doubly_buffer,
39350: e58dc014 str ip, [sp, #20] <== NOT EXECUTED
singly);
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
39354: eb0001be bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
singly_block, true);
if (rc > 0)
39358: e3500000 cmp r0, #0 <== NOT EXECUTED 3935c: daffff8b ble 39190 <rtems_rfs_block_map_grow+0x140> <== NOT EXECUTED 39360: e1a0a000 mov sl, r0 <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, block);
39364: e3a01000 mov r1, #0 <== NOT EXECUTED 39368: e1a00006 mov r0, r6 <== NOT EXECUTED 3936c: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 39370: eb000dcb bl 3caa4 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
map->last_data_block = block;
map->dirty = true;
}
return 0;
}
39374: e1a0000a mov r0, sl <== NOT EXECUTED
39378: e28dd01c add sp, sp, #28 <== NOT EXECUTED
3937c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
&map->blocks[singly],
upping);
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
39380: e280b009 add fp, r0, #9 <== NOT EXECUTED 39384: e794210b ldr r2, [r4, fp, lsl #2] <== NOT EXECUTED 39388: e1a00006 mov r0, r6 <== NOT EXECUTED 3938c: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 39390: e3a03001 mov r3, #1 <== NOT EXECUTED 39394: eb0001ae bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED 39398: eaffff7a b 39188 <rtems_rfs_block_map_grow+0x138> <== NOT EXECUTED
return rc;
}
}
else
{
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
3939c: e28aa009 add sl, sl, #9 <== NOT EXECUTED 393a0: e794210a ldr r2, [r4, sl, lsl #2] <== NOT EXECUTED 393a4: e1a00006 mov r0, r6 <== NOT EXECUTED 393a8: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 393ac: e3a03001 mov r3, #1 <== NOT EXECUTED 393b0: eb0001a7 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
393b4: e3500000 cmp r0, #0 <== NOT EXECUTED 393b8: daffffb5 ble 39294 <rtems_rfs_block_map_grow+0x244> <== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
393bc: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 393c0: e1a0100b mov r1, fp <== NOT EXECUTED 393c4: e1a0a000 mov sl, r0 <== NOT EXECUTED 393c8: e1a00006 mov r0, r6 <== NOT EXECUTED 393cc: eb000db4 bl 3caa4 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
393d0: e1a00006 mov r0, r6 <== NOT EXECUTED 393d4: e1a0100b mov r1, fp <== NOT EXECUTED 393d8: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 393dc: eb000db0 bl 3caa4 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
393e0: eaffffe3 b 39374 <rtems_rfs_block_map_grow+0x324> <== NOT EXECUTED
/*
* Allocate a block at a time. The buffer handles hold the blocks so adding
* this way does not thrash the cache with lots of requests.
*/
for (b = 0; b < blocks; b++)
393e4: e3a0a000 mov sl, #0 <== NOT EXECUTED 393e8: eaffffe1 b 39374 <rtems_rfs_block_map_grow+0x324> <== NOT EXECUTED 393ec: e1a0a000 mov sl, r0 <== NOT EXECUTED 393f0: eaffffdf b 39374 <rtems_rfs_block_map_grow+0x324> <== NOT EXECUTED 393f4: e1a0a000 mov sl, r0 <== NOT EXECUTED
&map->singly_buffer,
&singly_block,
false);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, block);
393f8: e1a01007 mov r1, r7 <== NOT EXECUTED 393fc: e1a00006 mov r0, r6 <== NOT EXECUTED 39400: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 39404: eb000da6 bl 3caa4 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
39408: eaffffd9 b 39374 <rtems_rfs_block_map_grow+0x324> <== NOT EXECUTED
&map->doubly_buffer,
&map->blocks[doubly],
upping);
if (rc > 0)
{
rtems_rfs_group_bitmap_free (fs, false, singly_block);
3940c: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 39410: e1a0a000 mov sl, r0 <== NOT EXECUTED 39414: e3a01000 mov r1, #0 <== NOT EXECUTED 39418: e1a00006 mov r0, r6 <== NOT EXECUTED 3941c: eb000da0 bl 3caa4 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, false, block);
39420: e1a00006 mov r0, r6 <== NOT EXECUTED 39424: e3a01000 mov r1, #0 <== NOT EXECUTED 39428: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 3942c: eb000d9c bl 3caa4 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
39430: eaffffcf b 39374 <rtems_rfs_block_map_grow+0x324> <== NOT EXECUTED
00038f20 <rtems_rfs_block_map_indirect_alloc>:
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
38f20: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
38f24: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
38f28: e1a04001 mov r4, r1 <== NOT EXECUTED
38f2c: e1a05002 mov r5, r2 <== NOT EXECUTED
38f30: e1a08003 mov r8, r3 <== NOT EXECUTED
int rc; /* * Save the new block locally because upping can have *block pointing to the * slots which are cleared when upping. */ rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
38f34: e591101c ldr r1, [r1, #28] <== NOT EXECUTED 38f38: e3a02000 mov r2, #0 <== NOT EXECUTED 38f3c: e1a0300d mov r3, sp <== NOT EXECUTED
rtems_rfs_block_map_indirect_alloc (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no* block,
bool upping)
{
38f40: e1a06000 mov r6, r0 <== NOT EXECUTED 38f44: e5dd7020 ldrb r7, [sp, #32] <== NOT EXECUTED
int rc; /* * Save the new block locally because upping can have *block pointing to the * slots which are cleared when upping. */ rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
38f48: eb000efd bl 3cb44 <rtems_rfs_group_bitmap_alloc> <== NOT EXECUTED
if (rc > 0)
38f4c: e250a000 subs sl, r0, #0 <== NOT EXECUTED 38f50: da000002 ble 38f60 <rtems_rfs_block_map_indirect_alloc+0x40><== NOT EXECUTED
} rtems_rfs_buffer_mark_dirty (buffer); *block = new_block; map->last_map_block = new_block; return 0; }
38f54: e1a0000a mov r0, sl <== NOT EXECUTED
38f58: e28dd004 add sp, sp, #4 <== NOT EXECUTED
38f5c: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
* slots which are cleared when upping.
*/
rc = rtems_rfs_group_bitmap_alloc (fs, map->last_map_block, false, &new_block);
if (rc > 0)
return rc;
rc = rtems_rfs_buffer_handle_request (fs, buffer, new_block, false);
38f60: e1a00006 mov r0, r6 <== NOT EXECUTED 38f64: e1a01005 mov r1, r5 <== NOT EXECUTED 38f68: e59d2000 ldr r2, [sp] <== NOT EXECUTED 38f6c: e3a03000 mov r3, #0 <== NOT EXECUTED 38f70: eb0002b7 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
38f74: e250a000 subs sl, r0, #0 <== NOT EXECUTED 38f78: da000004 ble 38f90 <rtems_rfs_block_map_indirect_alloc+0x70><== NOT EXECUTED
{
rtems_rfs_group_bitmap_free (fs, false, new_block);
38f7c: e1a00006 mov r0, r6 <== NOT EXECUTED 38f80: e3a01000 mov r1, #0 <== NOT EXECUTED 38f84: e59d2000 ldr r2, [sp] <== NOT EXECUTED 38f88: eb000ec5 bl 3caa4 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
return rc;
38f8c: eafffff0 b 38f54 <rtems_rfs_block_map_indirect_alloc+0x34> <== NOT EXECUTED
} memset (rtems_rfs_buffer_data (buffer), 0xff, rtems_rfs_fs_block_size (fs));
38f90: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED 38f94: e5962008 ldr r2, [r6, #8] <== NOT EXECUTED 38f98: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 38f9c: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED 38fa0: eb003549 bl 464cc <memset> <== NOT EXECUTED
if (upping)
38fa4: e3570000 cmp r7, #0 <== NOT EXECUTED 38fa8: 0a000021 beq 39034 <rtems_rfs_block_map_indirect_alloc+0x114><== NOT EXECUTED 38fac: e1a02004 mov r2, r4 <== NOT EXECUTED 38fb0: e3a03000 mov r3, #0 <== NOT EXECUTED
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
38fb4: e3a0c001 mov ip, #1 <== NOT EXECUTED 38fb8: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED 38fbc: e5d20027 ldrb r0, [r2, #39] ; 0x27 <== NOT EXECUTED 38fc0: e5911020 ldr r1, [r1, #32] <== NOT EXECUTED 38fc4: e7c10003 strb r0, [r1, r3] <== NOT EXECUTED 38fc8: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED 38fcc: e5911020 ldr r1, [r1, #32] <== NOT EXECUTED 38fd0: e1d202b6 ldrh r0, [r2, #38] ; 0x26 <== NOT EXECUTED 38fd4: e0811003 add r1, r1, r3 <== NOT EXECUTED 38fd8: e5c10001 strb r0, [r1, #1] <== NOT EXECUTED 38fdc: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED 38fe0: e5920024 ldr r0, [r2, #36] ; 0x24 <== NOT EXECUTED 38fe4: e5911020 ldr r1, [r1, #32] <== NOT EXECUTED 38fe8: e1a00420 lsr r0, r0, #8 <== NOT EXECUTED 38fec: e0811003 add r1, r1, r3 <== NOT EXECUTED 38ff0: e5c10002 strb r0, [r1, #2] <== NOT EXECUTED 38ff4: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED 38ff8: e5911020 ldr r1, [r1, #32] <== NOT EXECUTED 38ffc: e5920024 ldr r0, [r2, #36] ; 0x24 <== NOT EXECUTED 39000: e0811003 add r1, r1, r3 <== NOT EXECUTED 39004: e2833004 add r3, r3, #4 <== NOT EXECUTED
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
39008: e3530014 cmp r3, #20 <== NOT EXECUTED
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
3900c: e5c10003 strb r0, [r1, #3] <== NOT EXECUTED 39010: e2822004 add r2, r2, #4 <== NOT EXECUTED 39014: e5c5c000 strb ip, [r5] <== NOT EXECUTED
{
int b;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_GROW))
printf ("rtems-rfs: block-map-grow: upping: block-count=%" PRId32 "\n",
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
39018: 1affffe6 bne 38fb8 <rtems_rfs_block_map_indirect_alloc+0x98><== NOT EXECUTED
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
3901c: e3a03000 mov r3, #0 <== NOT EXECUTED 39020: e5843034 str r3, [r4, #52] ; 0x34 <== NOT EXECUTED 39024: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED 39028: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED 3902c: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED 39030: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED
} rtems_rfs_buffer_mark_dirty (buffer); *block = new_block;
39034: e59d3000 ldr r3, [sp] <== NOT EXECUTED
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
39038: e3a02001 mov r2, #1 <== NOT EXECUTED
*block = new_block;
3903c: e5883000 str r3, [r8] <== NOT EXECUTED
map->size.count);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_block_set_number (buffer, b, map->blocks[b]);
memset (map->blocks, 0, sizeof (map->blocks));
}
rtems_rfs_buffer_mark_dirty (buffer);
39040: e5c52000 strb r2, [r5] <== NOT EXECUTED
*block = new_block; map->last_map_block = new_block;
39044: e584301c str r3, [r4, #28] <== NOT EXECUTED 39048: e3a0a000 mov sl, #0 <== NOT EXECUTED
return 0;
3904c: eaffffc0 b 38f54 <rtems_rfs_block_map_indirect_alloc+0x34> <== NOT EXECUTED
00038b88 <rtems_rfs_block_map_indirect_shrink>:
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no indirect,
rtems_rfs_block_no index)
{
38b88: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
38b8c: e59dc010 ldr ip, [sp, #16] <== NOT EXECUTED
* block to be freed and the indirect block is now also free, or we have only * one indirect table and we can fit the remaining blocks into the inode, * then either move to the next indirect block or move the remaining blocks * into the inode and free the indirect table's block. */ if ((index == 0) ||
38b90: e35c0000 cmp ip, #0 <== NOT EXECUTED
rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_buffer_handle* buffer,
rtems_rfs_block_no indirect,
rtems_rfs_block_no index)
{
38b94: e1a04001 mov r4, r1 <== NOT EXECUTED
* block to be freed and the indirect block is now also free, or we have only * one indirect table and we can fit the remaining blocks into the inode, * then either move to the next indirect block or move the remaining blocks * into the inode and free the indirect table's block. */ if ((index == 0) ||
38b98: 0a00001d beq 38c14 <rtems_rfs_block_map_indirect_shrink+0x8c><== NOT EXECUTED
38b9c: e35c0005 cmp ip, #5 <== NOT EXECUTED
38ba0: 03530000 cmpeq r3, #0 <== NOT EXECUTED
38ba4: 13a0c000 movne ip, #0 <== NOT EXECUTED
38ba8: 03a0c001 moveq ip, #1 <== NOT EXECUTED
38bac: 11a0000c movne r0, ip <== NOT EXECUTED
38bb0: 18bd8070 popne {r4, r5, r6, pc} <== NOT EXECUTED
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
38bb4: e5923008 ldr r3, [r2, #8] <== NOT EXECUTED 38bb8: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 38bbc: e5915024 ldr r5, [r1, #36] ; 0x24 <== NOT EXECUTED 38bc0: e1a02001 mov r2, r1 <== NOT EXECUTED
* @param indirect The index index in the inode's block table. * @param index The index in the indirect table of the block. * @return int The error number (errno). No error if 0. */ static int rtems_rfs_block_map_indirect_shrink (rtems_rfs_file_system* fs,
38bc4: e2836014 add r6, r3, #20 <== NOT EXECUTED
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_block_get_number (buffer, b);
38bc8: e5d31001 ldrb r1, [r3, #1] <== NOT EXECUTED 38bcc: e5d3c000 ldrb ip, [r3] <== NOT EXECUTED 38bd0: e5d3e003 ldrb lr, [r3, #3] <== NOT EXECUTED 38bd4: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 38bd8: e1811c0c orr r1, r1, ip, lsl #24 <== NOT EXECUTED 38bdc: e5d3c002 ldrb ip, [r3, #2] <== NOT EXECUTED 38be0: e181100e orr r1, r1, lr <== NOT EXECUTED 38be4: e2833004 add r3, r3, #4 <== NOT EXECUTED 38be8: e181140c orr r1, r1, ip, lsl #8 <== NOT EXECUTED
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
38bec: e1530006 cmp r3, r6 <== NOT EXECUTED
map->blocks[b] = rtems_rfs_block_get_number (buffer, b);
38bf0: e5821024 str r1, [r2, #36] ; 0x24 <== NOT EXECUTED 38bf4: e2822004 add r2, r2, #4 <== NOT EXECUTED
{
/*
* Move to direct inode access.
*/
int b;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
38bf8: 1afffff2 bne 38bc8 <rtems_rfs_block_map_indirect_shrink+0x40><== NOT EXECUTED
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
38bfc: e3a01000 mov r1, #0 <== NOT EXECUTED 38c00: e1a02005 mov r2, r5 <== NOT EXECUTED 38c04: eb000fa6 bl 3caa4 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
38c08: e3500000 cmp r0, #0 <== NOT EXECUTED
return rc;
map->last_map_block = block_to_free;
38c0c: d584501c strle r5, [r4, #28] <== NOT EXECUTED
}
return rc;
}
38c10: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* into the inode and free the indirect table's block.
*/
if ((index == 0) ||
((indirect == 0) && (index == RTEMS_RFS_INODE_BLOCKS)))
{
rtems_rfs_block_no block_to_free = map->blocks[indirect];
38c14: e2833009 add r3, r3, #9 <== NOT EXECUTED 38c18: e7915103 ldr r5, [r1, r3, lsl #2] <== NOT EXECUTED
else
{
/*
* One less singly indirect block in the inode.
*/
map->blocks[indirect] = 0;
38c1c: e781c103 str ip, [r1, r3, lsl #2] <== NOT EXECUTED
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
38c20: e1a02005 mov r2, r5 <== NOT EXECUTED 38c24: e3a01000 mov r1, #0 <== NOT EXECUTED 38c28: eb000f9d bl 3caa4 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
38c2c: e3500000 cmp r0, #0 <== NOT EXECUTED
return rc;
map->last_map_block = block_to_free;
38c30: d584501c strle r5, [r4, #28] <== NOT EXECUTED
}
return rc;
}
38c34: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
00038ae4 <rtems_rfs_block_map_next_block>:
int
rtems_rfs_block_map_next_block (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_block_no* block)
{
38ae4: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_rfs_block_pos bpos; bpos.bno = map->bpos.bno + 1;
38ae8: e591e010 ldr lr, [r1, #16] <== NOT EXECUTED
int
rtems_rfs_block_map_next_block (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_block_no* block)
{
38aec: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
rtems_rfs_block_pos bpos; bpos.bno = map->bpos.bno + 1; bpos.boff = 0;
38af0: e3a0c000 mov ip, #0 <== NOT EXECUTED
int
rtems_rfs_block_map_next_block (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_block_no* block)
{
38af4: e1a03002 mov r3, r2 <== NOT EXECUTED
rtems_rfs_block_pos bpos; bpos.bno = map->bpos.bno + 1;
38af8: e28ee001 add lr, lr, #1 <== NOT EXECUTED
bpos.boff = 0; bpos.block = 0; return rtems_rfs_block_map_find (fs, map, &bpos, block);
38afc: e1a0200d mov r2, sp <== NOT EXECUTED
rtems_rfs_block_map_next_block (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_block_no* block)
{
rtems_rfs_block_pos bpos;
bpos.bno = map->bpos.bno + 1;
38b00: e58de000 str lr, [sp] <== NOT EXECUTED
bpos.boff = 0; bpos.block = 0;
38b04: e58dc008 str ip, [sp, #8] <== NOT EXECUTED
rtems_rfs_block_map* map,
rtems_rfs_block_no* block)
{
rtems_rfs_block_pos bpos;
bpos.bno = map->bpos.bno + 1;
bpos.boff = 0;
38b08: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
bpos.block = 0; return rtems_rfs_block_map_find (fs, map, &bpos, block);
38b0c: ebffff99 bl 38978 <rtems_rfs_block_map_find> <== NOT EXECUTED
}
38b10: e28dd00c add sp, sp, #12 <== NOT EXECUTED
38b14: e8bd8000 pop {pc} <== NOT EXECUTED
00039600 <rtems_rfs_block_map_open>:
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* inode,
rtems_rfs_block_map* map)
{
39600: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
* Set the count to 0 so at least find fails, then open the handle and make
* sure the inode has been loaded into memory. If we did not load the inode
* do not unload it. The caller may assume it is still loaded when we return.
*/
map->dirty = false;
39604: e3a05000 mov r5, #0 <== NOT EXECUTED 39608: e5c25000 strb r5, [r2] <== NOT EXECUTED
map->inode = NULL;
3960c: e5825004 str r5, [r2, #4] <== NOT EXECUTED
* @param size A pointer to the block size.
*/
static inline void
rtems_rfs_block_set_size_zero (rtems_rfs_block_size* size)
{
size->count = 0;
39610: e5825008 str r5, [r2, #8] <== NOT EXECUTED
size->offset = 0;
39614: e582500c str r5, [r2, #12] <== NOT EXECUTED
* @param bpos A pointer to the block position.
*/
static inline void
rtems_rfs_block_set_bpos_zero (rtems_rfs_block_pos* bpos)
{
bpos->bno = 0;
39618: e5825010 str r5, [r2, #16] <== NOT EXECUTED
bpos->boff = 0;
3961c: e5825014 str r5, [r2, #20] <== NOT EXECUTED
bpos->block = 0;
39620: e5825018 str r5, [r2, #24] <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
39624: e5c25038 strb r5, [r2, #56] ; 0x38 <== NOT EXECUTED
handle->bnum = 0;
39628: e582503c str r5, [r2, #60] ; 0x3c <== NOT EXECUTED
handle->buffer = NULL;
3962c: e5825040 str r5, [r2, #64] ; 0x40 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
39630: e5c25044 strb r5, [r2, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
39634: e5825048 str r5, [r2, #72] ; 0x48 <== NOT EXECUTED
handle->buffer = NULL;
39638: e582504c str r5, [r2, #76] ; 0x4c <== NOT EXECUTED
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* inode,
rtems_rfs_block_map* map)
{
3963c: e1a04002 mov r4, r2 <== NOT EXECUTED 39640: e1a07000 mov r7, r0 <== NOT EXECUTED 39644: e1a06001 mov r6, r1 <== NOT EXECUTED
return rc;
rc = rtems_rfs_buffer_handle_open (fs, &map->doubly_buffer);
if (rc > 0)
return rc;
rc = rtems_rfs_inode_load (fs, inode);
39648: eb000eed bl 3d204 <rtems_rfs_inode_load> <== NOT EXECUTED
if (rc > 0)
3964c: e2508000 subs r8, r0, #0 <== NOT EXECUTED 39650: ca000035 bgt 3972c <rtems_rfs_block_map_open+0x12c> <== NOT EXECUTED
/*
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
39654: e596100c ldr r1, [r6, #12] <== NOT EXECUTED 39658: e5846004 str r6, [r4, #4] <== NOT EXECUTED 3965c: e281301c add r3, r1, #28 <== NOT EXECUTED 39660: e1a02004 mov r2, r4 <== NOT EXECUTED
block_size = rtems_rfs_fs_block_size (fs);
return (((uint64_t) (size->count - 1)) * block_size) + offset;
}
int
rtems_rfs_block_map_open (rtems_rfs_file_system* fs,
39664: e2818030 add r8, r1, #48 ; 0x30 <== NOT EXECUTED
* Extract the block and block count data from the inode into the targets
* byte order.
*/
map->inode = inode;
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
39668: e5d30001 ldrb r0, [r3, #1] <== NOT EXECUTED 3966c: e5d3c000 ldrb ip, [r3] <== NOT EXECUTED 39670: e5d35003 ldrb r5, [r3, #3] <== NOT EXECUTED 39674: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED 39678: e1800c0c orr r0, r0, ip, lsl #24 <== NOT EXECUTED 3967c: e5d3c002 ldrb ip, [r3, #2] <== NOT EXECUTED 39680: e1800005 orr r0, r0, r5 <== NOT EXECUTED 39684: e2833004 add r3, r3, #4 <== NOT EXECUTED 39688: e180040c orr r0, r0, ip, lsl #8 <== NOT EXECUTED
/* * Extract the block and block count data from the inode into the targets * byte order. */ map->inode = inode; for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
3968c: e1530008 cmp r3, r8 <== NOT EXECUTED
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
39690: e5820024 str r0, [r2, #36] ; 0x24 <== NOT EXECUTED 39694: e2822004 add r2, r2, #4 <== NOT EXECUTED
/* * Extract the block and block count data from the inode into the targets * byte order. */ map->inode = inode; for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
39698: 1afffff2 bne 39668 <rtems_rfs_block_map_open+0x68> <== NOT EXECUTED
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
3969c: e281300c add r3, r1, #12 <== NOT EXECUTED
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
map->size.count = rtems_rfs_inode_get_block_count (inode);
396a0: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED 396a4: e5d1000c ldrb r0, [r1, #12] <== NOT EXECUTED 396a8: e5d3c001 ldrb ip, [r3, #1] <== NOT EXECUTED 396ac: e1820c00 orr r0, r2, r0, lsl #24 <== NOT EXECUTED 396b0: e5d32002 ldrb r2, [r3, #2] <== NOT EXECUTED 396b4: e180380c orr r3, r0, ip, lsl #16 <== NOT EXECUTED 396b8: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED 396bc: e5843008 str r3, [r4, #8] <== NOT EXECUTED
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
396c0: e5d1200a ldrb r2, [r1, #10] <== NOT EXECUTED 396c4: e5d1300b ldrb r3, [r1, #11] <== NOT EXECUTED 396c8: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED 396cc: e584300c str r3, [r4, #12] <== NOT EXECUTED
* @return uint32_t The last map block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_map_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_map_block);
396d0: e2813030 add r3, r1, #48 ; 0x30 <== NOT EXECUTED
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
396d4: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED 396d8: e5d10030 ldrb r0, [r1, #48] ; 0x30 <== NOT EXECUTED 396dc: e5d3c001 ldrb ip, [r3, #1] <== NOT EXECUTED 396e0: e1820c00 orr r0, r2, r0, lsl #24 <== NOT EXECUTED 396e4: e5d32002 ldrb r2, [r3, #2] <== NOT EXECUTED 396e8: e180380c orr r3, r0, ip, lsl #16 <== NOT EXECUTED 396ec: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED 396f0: e584301c str r3, [r4, #28] <== NOT EXECUTED
* @return uint32_t The last data block number.
*/
static inline uint32_t
rtems_rfs_inode_get_last_data_block (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->last_data_block);
396f4: e2813034 add r3, r1, #52 ; 0x34 <== NOT EXECUTED
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
396f8: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED 396fc: e5d11034 ldrb r1, [r1, #52] ; 0x34 <== NOT EXECUTED 39700: e5d30001 ldrb r0, [r3, #1] <== NOT EXECUTED 39704: e1821c01 orr r1, r2, r1, lsl #24 <== NOT EXECUTED 39708: e5d32002 ldrb r2, [r3, #2] <== NOT EXECUTED 3970c: e1813800 orr r3, r1, r0, lsl #16 <== NOT EXECUTED 39710: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, inode, false);
39714: e1a00007 mov r0, r7 <== NOT EXECUTED 39718: e1a01006 mov r1, r6 <== NOT EXECUTED 3971c: e3a02000 mov r2, #0 <== NOT EXECUTED
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
map->blocks[b] = rtems_rfs_inode_get_block (inode, b);
map->size.count = rtems_rfs_inode_get_block_count (inode);
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
39720: e5843020 str r3, [r4, #32] <== NOT EXECUTED
rc = rtems_rfs_inode_unload (fs, inode, false);
return rc;
}
39724: e8bd41f0 pop {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
map->size.count = rtems_rfs_inode_get_block_count (inode);
map->size.offset = rtems_rfs_inode_get_block_offset (inode);
map->last_map_block = rtems_rfs_inode_get_last_map_block (inode);
map->last_data_block = rtems_rfs_inode_get_last_data_block (inode);
rc = rtems_rfs_inode_unload (fs, inode, false);
39728: ea000e7e b 3d128 <rtems_rfs_inode_unload> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3972c: e2841038 add r1, r4, #56 ; 0x38 <== NOT EXECUTED 39730: e1a00007 mov r0, r7 <== NOT EXECUTED 39734: eb00007c bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
39738: e5c45038 strb r5, [r4, #56] ; 0x38 <== NOT EXECUTED
handle->bnum = 0;
3973c: e584503c str r5, [r4, #60] ; 0x3c <== NOT EXECUTED
handle->buffer = NULL;
39740: e5845040 str r5, [r4, #64] ; 0x40 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
39744: e1a00007 mov r0, r7 <== NOT EXECUTED 39748: e2841044 add r1, r4, #68 ; 0x44 <== NOT EXECUTED 3974c: eb000076 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false; handle->bnum = 0; handle->buffer = NULL;
39750: e584504c str r5, [r4, #76] ; 0x4c <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
39754: e5c45044 strb r5, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
39758: e5845048 str r5, [r4, #72] ; 0x48 <== NOT EXECUTED
return rc;
}
3975c: e1a00008 mov r0, r8 <== NOT EXECUTED
39760: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
00038b18 <rtems_rfs_block_map_seek>:
int
rtems_rfs_block_map_seek (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_pos_rel offset,
rtems_rfs_block_no* block)
{
38b18: e92d43f0 push {r4, r5, r6, r7, r8, r9, lr} <== NOT EXECUTED
rtems_rfs_block_pos bpos; rtems_rfs_block_copy_bpos (&bpos, &map->bpos);
38b1c: e591c014 ldr ip, [r1, #20] <== NOT EXECUTED
static inline void
rtems_rfs_block_add_pos (rtems_rfs_file_system* fs,
rtems_rfs_pos_rel offset,
rtems_rfs_block_pos* bpos)
{
rtems_rfs_block_get_bpos (fs,
38b20: e5905008 ldr r5, [r0, #8] <== NOT EXECUTED 38b24: e591e010 ldr lr, [r1, #16] <== NOT EXECUTED
int
rtems_rfs_block_map_seek (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_pos_rel offset,
rtems_rfs_block_no* block)
{
38b28: e1a04001 mov r4, r1 <== NOT EXECUTED 38b2c: e021ce95 mla r1, r5, lr, ip <== NOT EXECUTED 38b30: e0928001 adds r8, r2, r1 <== NOT EXECUTED 38b34: e24dd00c sub sp, sp, #12 <== NOT EXECUTED 38b38: e2a39000 adc r9, r3, #0 <== NOT EXECUTED
rtems_rfs_block_pos bpos; rtems_rfs_block_copy_bpos (&bpos, &map->bpos);
38b3c: e5947018 ldr r7, [r4, #24] <== NOT EXECUTED
int
rtems_rfs_block_map_seek (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
rtems_rfs_pos_rel offset,
rtems_rfs_block_no* block)
{
38b40: e1a06000 mov r6, r0 <== NOT EXECUTED 38b44: e1a01008 mov r1, r8 <== NOT EXECUTED 38b48: e1a02009 mov r2, r9 <== NOT EXECUTED 38b4c: e1a0300d mov r3, sp <== NOT EXECUTED
rtems_rfs_block_pos bpos; rtems_rfs_block_copy_bpos (&bpos, &map->bpos);
38b50: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 38b54: e58d7008 str r7, [sp, #8] <== NOT EXECUTED 38b58: e58de000 str lr, [sp] <== NOT EXECUTED 38b5c: ebffff27 bl 38800 <rtems_rfs_block_get_bpos> <== NOT EXECUTED
rtems_rfs_block_get_pos (fs, bpos) + offset,
bpos);
bpos->block = 0;
38b60: e3a0c000 mov ip, #0 <== NOT EXECUTED
rtems_rfs_block_add_pos (fs, offset, &bpos); return rtems_rfs_block_map_find (fs, map, &bpos, block);
38b64: e1a00006 mov r0, r6 <== NOT EXECUTED 38b68: e1a01004 mov r1, r4 <== NOT EXECUTED 38b6c: e1a0200d mov r2, sp <== NOT EXECUTED 38b70: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED
static inline void
rtems_rfs_block_add_pos (rtems_rfs_file_system* fs,
rtems_rfs_pos_rel offset,
rtems_rfs_block_pos* bpos)
{
rtems_rfs_block_get_bpos (fs,
38b74: e1a0500d mov r5, sp <== NOT EXECUTED
rtems_rfs_block_get_pos (fs, bpos) + offset,
bpos);
bpos->block = 0;
38b78: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 38b7c: ebffff7d bl 38978 <rtems_rfs_block_map_find> <== NOT EXECUTED
}
38b80: e28dd00c add sp, sp, #12 <== NOT EXECUTED
38b84: e8bd83f0 pop {r4, r5, r6, r7, r8, r9, pc} <== NOT EXECUTED
00038c38 <rtems_rfs_block_map_shrink>:
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
38c38: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if (map->size.count == 0)
38c3c: e5918008 ldr r8, [r1, #8] <== NOT EXECUTED 38c40: e3580000 cmp r8, #0 <== NOT EXECUTED
int
rtems_rfs_block_map_shrink (rtems_rfs_file_system* fs,
rtems_rfs_block_map* map,
size_t blocks)
{
38c44: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 38c48: e1a04001 mov r4, r1 <== NOT EXECUTED 38c4c: e1a05000 mov r5, r0 <== NOT EXECUTED 38c50: e1a0a002 mov sl, r2 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BLOCK_MAP_SHRINK))
printf ("rtems-rfs: block-map-shrink: entry: blocks=%zd count=%" PRIu32 "\n",
blocks, map->size.count);
if (map->size.count == 0)
38c54: e1a09008 mov r9, r8 <== NOT EXECUTED 38c58: 0a00007b beq 38e4c <rtems_rfs_block_map_shrink+0x214> <== NOT EXECUTED
return 0;
if (blocks > map->size.count)
38c5c: e1580002 cmp r8, r2 <== NOT EXECUTED 38c60: 3a00007c bcc 38e58 <rtems_rfs_block_map_shrink+0x220> <== NOT EXECUTED
blocks = map->size.count;
while (blocks)
38c64: e3520000 cmp r2, #0 <== NOT EXECUTED 38c68: 0a00006f beq 38e2c <rtems_rfs_block_map_shrink+0x1f4> <== NOT EXECUTED
{
/*
* Request the indirect block and then obtain the block number from the
* indirect block.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
38c6c: e2843038 add r3, r4, #56 ; 0x38 <== NOT EXECUTED 38c70: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
38c74: e2843044 add r3, r4, #68 ; 0x44 <== NOT EXECUTED 38c78: e58d300c str r3, [sp, #12] <== NOT EXECUTED 38c7c: ea000014 b 38cd4 <rtems_rfs_block_map_shrink+0x9c> <== NOT EXECUTED
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
38c80: e2899008 add r9, r9, #8 <== NOT EXECUTED
map->blocks[block] = 0;
38c84: e3a03000 mov r3, #0 <== NOT EXECUTED
{
/*
* We have less than RTEMS_RFS_INODE_BLOCKS so they are held in the
* inode.
*/
block_to_free = map->blocks[block];
38c88: e7946109 ldr r6, [r4, r9, lsl #2] <== NOT EXECUTED
map->blocks[block] = 0;
38c8c: e7843109 str r3, [r4, r9, lsl #2] <== NOT EXECUTED
{
rc = EIO;
break;
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
38c90: e1a00005 mov r0, r5 <== NOT EXECUTED 38c94: e3a01000 mov r1, #0 <== NOT EXECUTED 38c98: e1a02006 mov r2, r6 <== NOT EXECUTED 38c9c: eb000f80 bl 3caa4 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
38ca0: e3500000 cmp r0, #0 <== NOT EXECUTED 38ca4: ca000069 bgt 38e50 <rtems_rfs_block_map_shrink+0x218> <== NOT EXECUTED
return rc;
map->size.count--;
38ca8: e5948008 ldr r8, [r4, #8] <== NOT EXECUTED
map->size.offset = 0;
38cac: e3a03000 mov r3, #0 <== NOT EXECUTED
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
38cb0: e2489001 sub r9, r8, #1 <== NOT EXECUTED
map->size.offset = 0;
38cb4: e584300c str r3, [r4, #12] <== NOT EXECUTED
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
38cb8: e25aa001 subs sl, sl, #1 <== NOT EXECUTED
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
38cbc: e3a03001 mov r3, #1 <== NOT EXECUTED
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
map->size.offset = 0;
map->last_data_block = block_to_free;
38cc0: e5846020 str r6, [r4, #32] <== NOT EXECUTED
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
38cc4: e5849008 str r9, [r4, #8] <== NOT EXECUTED
map->size.offset = 0;
map->last_data_block = block_to_free;
map->dirty = true;
38cc8: e5c43000 strb r3, [r4] <== NOT EXECUTED
}
}
rc = rtems_rfs_group_bitmap_free (fs, false, block_to_free);
if (rc > 0)
return rc;
map->size.count--;
38ccc: e1a08009 mov r8, r9 <== NOT EXECUTED
return 0;
if (blocks > map->size.count)
blocks = map->size.count;
while (blocks)
38cd0: 0a000051 beq 38e1c <rtems_rfs_block_map_shrink+0x1e4> <== NOT EXECUTED
{
rtems_rfs_block_no block;
rtems_rfs_block_no block_to_free;
int rc;
block = map->size.count - 1;
38cd4: e249b001 sub fp, r9, #1 <== NOT EXECUTED
if (block < RTEMS_RFS_INODE_BLOCKS)
38cd8: e35b0004 cmp fp, #4 <== NOT EXECUTED 38cdc: 9affffe7 bls 38c80 <rtems_rfs_block_map_shrink+0x48> <== NOT EXECUTED
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
38ce0: e5956030 ldr r6, [r5, #48] ; 0x30 <== NOT EXECUTED 38ce4: e1a0000b mov r0, fp <== NOT EXECUTED 38ce8: e1a01006 mov r1, r6 <== NOT EXECUTED 38cec: eb008911 bl 5b138 <__umodsi3> <== NOT EXECUTED
singly = block / fs->blocks_per_block;
38cf0: e1a01006 mov r1, r6 <== NOT EXECUTED
* table of block numbers.
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
38cf4: e1a07000 mov r7, r0 <== NOT EXECUTED
singly = block / fs->blocks_per_block;
38cf8: e1a0000b mov r0, fp <== NOT EXECUTED 38cfc: eb008879 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
if (block < fs->block_map_singly_blocks)
38d00: e5953034 ldr r3, [r5, #52] ; 0x34 <== NOT EXECUTED 38d04: e15b0003 cmp fp, r3 <== NOT EXECUTED
*/
rtems_rfs_block_no direct;
rtems_rfs_block_no singly;
direct = block % fs->blocks_per_block;
singly = block / fs->blocks_per_block;
38d08: e1a0c000 mov ip, r0 <== NOT EXECUTED
if (block < fs->block_map_singly_blocks)
38d0c: 3a000053 bcc 38e60 <rtems_rfs_block_map_shrink+0x228> <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
singly, direct);
if (rc)
return rc;
}
else if (block < fs->block_map_doubly_blocks)
38d10: e5953038 ldr r3, [r5, #56] ; 0x38 <== NOT EXECUTED 38d14: e15b0003 cmp fp, r3 <== NOT EXECUTED 38d18: 2a00003f bcs 38e1c <rtems_rfs_block_map_shrink+0x1e4> <== NOT EXECUTED
* value is still valid for doubly indirect tables.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
38d1c: e1a01006 mov r1, r6 <== NOT EXECUTED 38d20: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 38d24: eb00886f bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
38d28: e2803009 add r3, r0, #9 <== NOT EXECUTED 38d2c: e7942103 ldr r2, [r4, r3, lsl #2] <== NOT EXECUTED
* value is still valid for doubly indirect tables.
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
38d30: e1a0b000 mov fp, r0 <== NOT EXECUTED
doubly_singly = singly % fs->blocks_per_block;
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
38d34: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 38d38: e1a00005 mov r0, r5 <== NOT EXECUTED 38d3c: e3a03001 mov r3, #1 <== NOT EXECUTED 38d40: eb000343 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
map->blocks[doubly], true);
if (rc > 0)
38d44: e3500000 cmp r0, #0 <== NOT EXECUTED 38d48: e59dc004 ldr ip, [sp, #4] <== NOT EXECUTED 38d4c: ca00003f bgt 38e50 <rtems_rfs_block_map_shrink+0x218> <== NOT EXECUTED
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
38d50: e1a01006 mov r1, r6 <== NOT EXECUTED 38d54: e1a0000c mov r0, ip <== NOT EXECUTED 38d58: eb0088f6 bl 5b138 <__umodsi3> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->doubly_buffer,
map->blocks[doubly], true);
if (rc > 0)
return rc;
singly = rtems_rfs_block_get_number (&map->doubly_buffer,
38d5c: e594304c ldr r3, [r4, #76] ; 0x4c <== NOT EXECUTED 38d60: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 38d64: e0832100 add r2, r3, r0, lsl #2 <== NOT EXECUTED 38d68: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED 38d6c: e7d39100 ldrb r9, [r3, r0, lsl #2] <== NOT EXECUTED 38d70: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED 38d74: e0833100 add r3, r3, r0, lsl #2 <== NOT EXECUTED 38d78: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 38d7c: e1819c09 orr r9, r1, r9, lsl #24 <== NOT EXECUTED 38d80: e1899802 orr r9, r9, r2, lsl #16 <== NOT EXECUTED 38d84: e1899403 orr r9, r9, r3, lsl #8 <== NOT EXECUTED
*/
rtems_rfs_block_no doubly;
rtems_rfs_block_no doubly_singly;
doubly = singly / fs->blocks_per_block;
doubly_singly = singly % fs->blocks_per_block;
38d88: e1a08000 mov r8, r0 <== NOT EXECUTED
doubly_singly);
/*
* Read the singly indirect table and get the block number.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
38d8c: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 38d90: e1a00005 mov r0, r5 <== NOT EXECUTED 38d94: e1a02009 mov r2, r9 <== NOT EXECUTED 38d98: e3a03001 mov r3, #1 <== NOT EXECUTED 38d9c: eb00032c bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
singly, true);
if (rc > 0)
38da0: e3500000 cmp r0, #0 <== NOT EXECUTED 38da4: ca000029 bgt 38e50 <rtems_rfs_block_map_shrink+0x218> <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
38da8: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED 38dac: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED 38db0: e0832107 add r2, r3, r7, lsl #2 <== NOT EXECUTED 38db4: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED 38db8: e7d36107 ldrb r6, [r3, r7, lsl #2] <== NOT EXECUTED 38dbc: e5d22001 ldrb r2, [r2, #1] <== NOT EXECUTED 38dc0: e0833107 add r3, r3, r7, lsl #2 <== NOT EXECUTED 38dc4: e1816c06 orr r6, r1, r6, lsl #24 <== NOT EXECUTED 38dc8: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 38dcc: e1866802 orr r6, r6, r2, lsl #16 <== NOT EXECUTED
direct);
if (direct == 0)
38dd0: e3570000 cmp r7, #0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
singly, true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
38dd4: e1866403 orr r6, r6, r3, lsl #8 <== NOT EXECUTED
direct);
if (direct == 0)
38dd8: 1affffac bne 38c90 <rtems_rfs_block_map_shrink+0x58> <== NOT EXECUTED
{
rc = rtems_rfs_group_bitmap_free (fs, false, singly);
38ddc: e1a01007 mov r1, r7 <== NOT EXECUTED 38de0: e1a00005 mov r0, r5 <== NOT EXECUTED 38de4: e1a02009 mov r2, r9 <== NOT EXECUTED 38de8: eb000f2d bl 3caa4 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
if (rc > 0)
38dec: e3500000 cmp r0, #0 <== NOT EXECUTED 38df0: ca000016 bgt 38e50 <rtems_rfs_block_map_shrink+0x218> <== NOT EXECUTED
return rc;
map->last_map_block = singly;
38df4: e584901c str r9, [r4, #28] <== NOT EXECUTED
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->doubly_buffer,
38df8: e1a0300b mov r3, fp <== NOT EXECUTED 38dfc: e1a00005 mov r0, r5 <== NOT EXECUTED 38e00: e1a01004 mov r1, r4 <== NOT EXECUTED 38e04: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 38e08: e58d8000 str r8, [sp] <== NOT EXECUTED 38e0c: ebffff5d bl 38b88 <rtems_rfs_block_map_indirect_shrink> <== NOT EXECUTED
doubly, doubly_singly);
if (rc)
38e10: e3500000 cmp r0, #0 <== NOT EXECUTED 38e14: 0affff9d beq 38c90 <rtems_rfs_block_map_shrink+0x58> <== NOT EXECUTED 38e18: ea00000c b 38e50 <rtems_rfs_block_map_shrink+0x218> <== NOT EXECUTED
map->last_data_block = block_to_free;
map->dirty = true;
blocks--;
}
if (map->size.count == 0)
38e1c: e3590000 cmp r9, #0 <== NOT EXECUTED
{
map->last_map_block = 0;
map->last_data_block = 0;
38e20: 05849020 streq r9, [r4, #32] <== NOT EXECUTED
blocks--;
}
if (map->size.count == 0)
{
map->last_map_block = 0;
38e24: 0584901c streq r9, [r4, #28] <== NOT EXECUTED
map->last_data_block = 0;
38e28: 01a09008 moveq r9, r8 <== NOT EXECUTED
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
38e2c: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED 38e30: e3530000 cmp r3, #0 <== NOT EXECUTED 38e34: 1a000026 bne 38ed4 <rtems_rfs_block_map_shrink+0x29c> <== NOT EXECUTED 38e38: e1590003 cmp r9, r3 <== NOT EXECUTED 38e3c: 9a000026 bls 38edc <rtems_rfs_block_map_shrink+0x2a4> <== NOT EXECUTED 38e40: e2492001 sub r2, r9, #1 <== NOT EXECUTED 38e44: e1530002 cmp r3, r2 <== NOT EXECUTED 38e48: 0a00002d beq 38f04 <rtems_rfs_block_map_shrink+0x2cc> <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
38e4c: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
38e50: e28dd010 add sp, sp, #16 <== NOT EXECUTED
38e54: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
blocks, map->size.count);
if (map->size.count == 0)
return 0;
if (blocks > map->size.count)
38e58: e1a0a008 mov sl, r8 <== NOT EXECUTED 38e5c: eaffff82 b 38c6c <rtems_rfs_block_map_shrink+0x34> <== NOT EXECUTED
{
/*
* Request the indirect block and then obtain the block number from the
* indirect block.
*/
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
38e60: e2803009 add r3, r0, #9 <== NOT EXECUTED 38e64: e7942103 ldr r2, [r4, r3, lsl #2] <== NOT EXECUTED 38e68: e1a00005 mov r0, r5 <== NOT EXECUTED 38e6c: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 38e70: e3a03001 mov r3, #1 <== NOT EXECUTED 38e74: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 38e78: eb0002f5 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
map->blocks[singly], true);
if (rc > 0)
38e7c: e3500000 cmp r0, #0 <== NOT EXECUTED 38e80: e59dc004 ldr ip, [sp, #4] <== NOT EXECUTED 38e84: cafffff1 bgt 38e50 <rtems_rfs_block_map_shrink+0x218> <== NOT EXECUTED
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
38e88: e5943040 ldr r3, [r4, #64] ; 0x40 <== NOT EXECUTED 38e8c: e593e020 ldr lr, [r3, #32] <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
38e90: e1a00005 mov r0, r5 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
38e94: e08e6107 add r6, lr, r7, lsl #2 <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
38e98: e1a0300c mov r3, ip <== NOT EXECUTED 38e9c: e1a01004 mov r1, r4 <== NOT EXECUTED 38ea0: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
38ea4: e5d6b002 ldrb fp, [r6, #2] <== NOT EXECUTED 38ea8: e5d69003 ldrb r9, [r6, #3] <== NOT EXECUTED 38eac: e7de8107 ldrb r8, [lr, r7, lsl #2] <== NOT EXECUTED 38eb0: e5d66001 ldrb r6, [r6, #1] <== NOT EXECUTED
direct);
rc = rtems_rfs_block_map_indirect_shrink (fs, map, &map->singly_buffer,
38eb4: e58d7000 str r7, [sp] <== NOT EXECUTED 38eb8: ebffff32 bl 38b88 <rtems_rfs_block_map_indirect_shrink> <== NOT EXECUTED
singly, direct);
if (rc)
38ebc: e3500000 cmp r0, #0 <== NOT EXECUTED 38ec0: 1affffe2 bne 38e50 <rtems_rfs_block_map_shrink+0x218> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &map->singly_buffer,
map->blocks[singly], true);
if (rc > 0)
return rc;
block_to_free = rtems_rfs_block_get_number (&map->singly_buffer,
38ec4: e1898c08 orr r8, r9, r8, lsl #24 <== NOT EXECUTED 38ec8: e1886806 orr r6, r8, r6, lsl #16 <== NOT EXECUTED 38ecc: e186640b orr r6, r6, fp, lsl #8 <== NOT EXECUTED 38ed0: eaffff6e b 38c90 <rtems_rfs_block_map_shrink+0x58> <== NOT EXECUTED
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
38ed4: e3590000 cmp r9, #0 <== NOT EXECUTED 38ed8: 1affffd6 bne 38e38 <rtems_rfs_block_map_shrink+0x200> <== NOT EXECUTED 38edc: e594300c ldr r3, [r4, #12] <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (&map->size, &map->bpos);
38ee0: e3530000 cmp r3, #0 <== NOT EXECUTED 38ee4: e5849010 str r9, [r4, #16] <== NOT EXECUTED 38ee8: e3a00000 mov r0, #0 <== NOT EXECUTED 38eec: 12499001 subne r9, r9, #1 <== NOT EXECUTED 38ef0: e5843014 str r3, [r4, #20] <== NOT EXECUTED 38ef4: e5840018 str r0, [r4, #24] <== NOT EXECUTED 38ef8: 15849010 strne r9, [r4, #16] <== NOT EXECUTED 38efc: 1affffd3 bne 38e50 <rtems_rfs_block_map_shrink+0x218> <== NOT EXECUTED 38f00: eaffffd1 b 38e4c <rtems_rfs_block_map_shrink+0x214> <== NOT EXECUTED
}
/*
* Keep the position inside the map.
*/
if (rtems_rfs_block_pos_past_end (&map->bpos, &map->size))
38f04: e5942014 ldr r2, [r4, #20] <== NOT EXECUTED 38f08: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 38f0c: e1520003 cmp r2, r3 <== NOT EXECUTED 38f10: 8afffff2 bhi 38ee0 <rtems_rfs_block_map_shrink+0x2a8> <== NOT EXECUTED 38f14: eaffffcc b 38e4c <rtems_rfs_block_map_shrink+0x214> <== NOT EXECUTED
00042a2c <rtems_rfs_buffer_bdbuf_release>:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
42a2c: e31100ff tst r1, #255 ; 0xff <== NOT EXECUTED
}
int
rtems_rfs_buffer_bdbuf_release (rtems_rfs_buffer* buffer,
bool modified)
{
42a30: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: bdbuf-release: block=%" PRIuPTR " bdbuf=%" PRIu32 " %s\n",
((intptr_t) buffer->user),
buffer->block, modified ? "(modified)" : "");
if (modified)
42a34: 0a000003 beq 42a48 <rtems_rfs_buffer_bdbuf_release+0x1c> <== NOT EXECUTED
sc = rtems_bdbuf_release_modified (buffer);
42a38: ebff067b bl 442c <rtems_bdbuf_release_modified> <== NOT EXECUTED
else
sc = rtems_bdbuf_release (buffer);
if (sc != RTEMS_SUCCESSFUL)
42a3c: e3500000 cmp r0, #0 <== NOT EXECUTED
#endif
rc = EIO;
}
return rc;
}
42a40: 13a00005 movne r0, #5 <== NOT EXECUTED
42a44: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
buffer->block, modified ? "(modified)" : "");
if (modified)
sc = rtems_bdbuf_release_modified (buffer);
else
sc = rtems_bdbuf_release (buffer);
42a48: ebff0699 bl 44b4 <rtems_bdbuf_release> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
42a4c: e3500000 cmp r0, #0 <== NOT EXECUTED
#endif
rc = EIO;
}
return rc;
}
42a50: 13a00005 movne r0, #5 <== NOT EXECUTED
42a54: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00042a58 <rtems_rfs_buffer_bdbuf_request>:
rtems_rfs_buffer** buffer)
{
rtems_status_code sc;
int rc = 0;
if (read)
42a58: e31200ff tst r2, #255 ; 0xff <== NOT EXECUTED
int
rtems_rfs_buffer_bdbuf_request (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block block,
bool read,
rtems_rfs_buffer** buffer)
{
42a5c: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
42a60: e1a02001 mov r2, r1 <== NOT EXECUTED
rtems_status_code sc;
int rc = 0;
if (read)
42a64: 0a000005 beq 42a80 <rtems_rfs_buffer_bdbuf_request+0x28> <== NOT EXECUTED
sc = rtems_bdbuf_read (rtems_rfs_fs_device (fs), block, buffer);
42a68: e590000c ldr r0, [r0, #12] <== NOT EXECUTED
42a6c: e8900003 ldm r0, {r0, r1} <== NOT EXECUTED
42a70: ebff0b20 bl 56f8 <rtems_bdbuf_read> <== NOT EXECUTED
else
sc = rtems_bdbuf_get (rtems_rfs_fs_device (fs), block, buffer);
if (sc != RTEMS_SUCCESSFUL)
42a74: e3500000 cmp r0, #0 <== NOT EXECUTED
#endif
rc = EIO;
}
return rc;
}
42a78: 13a00005 movne r0, #5 <== NOT EXECUTED
42a7c: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
int rc = 0;
if (read)
sc = rtems_bdbuf_read (rtems_rfs_fs_device (fs), block, buffer);
else
sc = rtems_bdbuf_get (rtems_rfs_fs_device (fs), block, buffer);
42a80: e590000c ldr r0, [r0, #12] <== NOT EXECUTED
42a84: e8900003 ldm r0, {r0, r1} <== NOT EXECUTED
42a88: ebff0ae6 bl 5628 <rtems_bdbuf_get> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
42a8c: e3500000 cmp r0, #0 <== NOT EXECUTED
#endif
rc = EIO;
}
return rc;
}
42a90: 13a00005 movne r0, #5 <== NOT EXECUTED
42a94: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
000398a8 <rtems_rfs_buffer_close>:
/*
* Change the block size to the media device size. It will release and sync
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
398a8: e590300c ldr r3, [r0, #12] <== NOT EXECUTED
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
398ac: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
/*
* Change the block size to the media device size. It will release and sync
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
398b0: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED
return 0;
}
int
rtems_rfs_buffer_close (rtems_rfs_file_system* fs)
{
398b4: e1a04000 mov r4, r0 <== NOT EXECUTED
/*
* Change the block size to the media device size. It will release and sync
* all buffers.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_media_block_size (fs));
398b8: ebffffe3 bl 3984c <rtems_rfs_buffer_setblksize> <== NOT EXECUTED 398bc: e1a05000 mov r5, r0 <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CLOSE))
printf ("rtems-rfs: buffer-close: set media block size failed: %d: %s\n",
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rtems_disk_release (fs->disk);
398c0: e594000c ldr r0, [r4, #12] <== NOT EXECUTED 398c4: ebff3458 bl 6a2c <rtems_disk_release> <== NOT EXECUTED
rc, strerror (rc));
}
#endif
return rc;
}
398c8: e1a00005 mov r0, r5 <== NOT EXECUTED
398cc: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00039c84 <rtems_rfs_buffer_handle_close>:
* @return int The error number (errno). No error if 0.
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
39c84: e92d4010 push {r4, lr} <== NOT EXECUTED
39c88: e1a04001 mov r4, r1 <== NOT EXECUTED
rtems_rfs_buffer_handle_release (fs, handle);
39c8c: ebffff26 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
39c90: e3a00000 mov r0, #0 <== NOT EXECUTED
handle->bnum = 0; handle->buffer = NULL;
39c94: e5840008 str r0, [r4, #8] <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
39c98: e5c40000 strb r0, [r4] <== NOT EXECUTED
handle->bnum = 0;
39c9c: e5840004 str r0, [r4, #4] <== NOT EXECUTED
handle->buffer = NULL; return 0; }
39ca0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0003992c <rtems_rfs_buffer_handle_release>:
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
3992c: e5913008 ldr r3, [r1, #8] <== NOT EXECUTED 39930: e3530000 cmp r3, #0 <== NOT EXECUTED
}
int
rtems_rfs_buffer_handle_release (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
39934: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
39938: e1a04001 mov r4, r1 <== NOT EXECUTED
3993c: e1a05000 mov r5, r0 <== NOT EXECUTED
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (handle))
39940: 01a06003 moveq r6, r3 <== NOT EXECUTED 39944: 0a000008 beq 3996c <rtems_rfs_buffer_handle_release+0x40> <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle),
rtems_rfs_buffer_dirty (handle) ? "(dirty)" : "",
rtems_rfs_buffer_refs (handle),
rtems_rfs_buffer_refs (handle) == 0 ? "BAD REF COUNT" : "");
if (rtems_rfs_buffer_refs (handle) > 0)
39948: e5936034 ldr r6, [r3, #52] ; 0x34 <== NOT EXECUTED 3994c: e3560000 cmp r6, #0 <== NOT EXECUTED
rtems_rfs_buffer_refs_down (handle);
39950: c2466001 subgt r6, r6, #1 <== NOT EXECUTED 39954: c5836034 strgt r6, [r3, #52] ; 0x34 <== NOT EXECUTED
if (rtems_rfs_buffer_refs (handle) == 0)
39958: e3560000 cmp r6, #0 <== NOT EXECUTED 3995c: 13a06000 movne r6, #0 <== NOT EXECUTED 39960: 0a000003 beq 39974 <rtems_rfs_buffer_handle_release+0x48> <== NOT EXECUTED
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
}
}
}
handle->buffer = NULL;
39964: e3a03000 mov r3, #0 <== NOT EXECUTED 39968: e5843008 str r3, [r4, #8] <== NOT EXECUTED
}
return rc;
}
3996c: e1a00006 mov r0, r6 <== NOT EXECUTED
39970: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
39974: e1a00003 mov r0, r3 <== NOT EXECUTED 39978: ebff4dcc bl d0b0 <_Chain_Extract> <== NOT EXECUTED
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
3997c: e595304c ldr r3, [r5, #76] ; 0x4c <== NOT EXECUTED
if (rtems_rfs_fs_no_local_cache (fs))
39980: e5952000 ldr r2, [r5] <== NOT EXECUTED
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
39984: e2433001 sub r3, r3, #1 <== NOT EXECUTED
if (rtems_rfs_fs_no_local_cache (fs))
39988: e3120002 tst r2, #2 <== NOT EXECUTED
rtems_rfs_buffer_refs_down (handle);
if (rtems_rfs_buffer_refs (handle) == 0)
{
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
3998c: e585304c str r3, [r5, #76] ; 0x4c <== NOT EXECUTED
if (rtems_rfs_fs_no_local_cache (fs))
39990: 1a00001c bne 39a08 <rtems_rfs_buffer_handle_release+0xdc> <== NOT EXECUTED
* head.
*
* This code stops a large series of transactions causing all the
* buffers in the cache being held in queues of this file system.
*/
if ((fs->release_count +
39994: e595205c ldr r2, [r5, #92] ; 0x5c <== NOT EXECUTED 39998: e595306c ldr r3, [r5, #108] ; 0x6c <== NOT EXECUTED
fs->release_modified_count) >= fs->max_held_buffers)
3999c: e595103c ldr r1, [r5, #60] ; 0x3c <== NOT EXECUTED
* head.
*
* This code stops a large series of transactions causing all the
* buffers in the cache being held in queues of this file system.
*/
if ((fs->release_count +
399a0: e0830002 add r0, r3, r2 <== NOT EXECUTED
fs->release_modified_count) >= fs->max_held_buffers)
399a4: e1500001 cmp r0, r1 <== NOT EXECUTED 399a8: 3a00000c bcc 399e0 <rtems_rfs_buffer_handle_release+0xb4> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_RELEASE))
printf ("rtems-rfs: buffer-release: local cache overflow:"
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
399ac: e1520003 cmp r2, r3 <== NOT EXECUTED 399b0: 8a000021 bhi 39a3c <rtems_rfs_buffer_handle_release+0x110> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
399b4: e2850060 add r0, r5, #96 ; 0x60 <== NOT EXECUTED 399b8: ebff4dc5 bl d0d4 <_Chain_Get> <== NOT EXECUTED
}
else
{
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
399bc: e595306c ldr r3, [r5, #108] ; 0x6c <== NOT EXECUTED 399c0: e2433001 sub r3, r3, #1 <== NOT EXECUTED 399c4: e585306c str r3, [r5, #108] ; 0x6c <== NOT EXECUTED 399c8: e3a06001 mov r6, #1 <== NOT EXECUTED
modified = true;
}
buffer->user = (void*) 0;
399cc: e3a03000 mov r3, #0 <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (buffer, modified);
399d0: e1a01006 mov r1, r6 <== NOT EXECUTED
buffer =
(rtems_rfs_buffer*) rtems_chain_get (&fs->release_modified);
fs->release_modified_count--;
modified = true;
}
buffer->user = (void*) 0;
399d4: e5803038 str r3, [r0, #56] ; 0x38 <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (buffer, modified);
399d8: eb002413 bl 42a2c <rtems_rfs_buffer_bdbuf_release> <== NOT EXECUTED 399dc: e1a06000 mov r6, r0 <== NOT EXECUTED
}
if (rtems_rfs_buffer_dirty (handle))
399e0: e5d43000 ldrb r3, [r4] <== NOT EXECUTED 399e4: e3530000 cmp r3, #0 <== NOT EXECUTED 399e8: 0a00000c beq 39a20 <rtems_rfs_buffer_handle_release+0xf4> <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
399ec: e2850060 add r0, r5, #96 ; 0x60 <== NOT EXECUTED 399f0: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 399f4: ebff4da2 bl d084 <_Chain_Append> <== NOT EXECUTED
{
rtems_chain_append (&fs->release_modified,
rtems_rfs_buffer_link (handle));
fs->release_modified_count++;
399f8: e595306c ldr r3, [r5, #108] ; 0x6c <== NOT EXECUTED 399fc: e2833001 add r3, r3, #1 <== NOT EXECUTED 39a00: e585306c str r3, [r5, #108] ; 0x6c <== NOT EXECUTED 39a04: eaffffd6 b 39964 <rtems_rfs_buffer_handle_release+0x38> <== NOT EXECUTED
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
{
handle->buffer->user = (void*) 0;
39a08: e5940008 ldr r0, [r4, #8] <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (handle->buffer,
39a0c: e5d41000 ldrb r1, [r4] <== NOT EXECUTED
rtems_chain_extract (rtems_rfs_buffer_link (handle));
fs->buffers_count--;
if (rtems_rfs_fs_no_local_cache (fs))
{
handle->buffer->user = (void*) 0;
39a10: e5806038 str r6, [r0, #56] ; 0x38 <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (handle->buffer,
39a14: eb002404 bl 42a2c <rtems_rfs_buffer_bdbuf_release> <== NOT EXECUTED 39a18: e1a06000 mov r6, r0 <== NOT EXECUTED 39a1c: eaffffd0 b 39964 <rtems_rfs_buffer_handle_release+0x38> <== NOT EXECUTED 39a20: e2850050 add r0, r5, #80 ; 0x50 <== NOT EXECUTED 39a24: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 39a28: ebff4d95 bl d084 <_Chain_Append> <== NOT EXECUTED
fs->release_modified_count++;
}
else
{
rtems_chain_append (&fs->release, rtems_rfs_buffer_link (handle));
fs->release_count++;
39a2c: e595305c ldr r3, [r5, #92] ; 0x5c <== NOT EXECUTED 39a30: e2833001 add r3, r3, #1 <== NOT EXECUTED 39a34: e585305c str r3, [r5, #92] ; 0x5c <== NOT EXECUTED 39a38: eaffffc9 b 39964 <rtems_rfs_buffer_handle_release+0x38> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
39a3c: e2850050 add r0, r5, #80 ; 0x50 <== NOT EXECUTED 39a40: ebff4da3 bl d0d4 <_Chain_Get> <== NOT EXECUTED
" %" PRIu32 "\n", fs->release_count + fs->release_modified_count);
if (fs->release_count > fs->release_modified_count)
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (&fs->release);
fs->release_count--;
39a44: e595305c ldr r3, [r5, #92] ; 0x5c <== NOT EXECUTED 39a48: e2433001 sub r3, r3, #1 <== NOT EXECUTED 39a4c: e585305c str r3, [r5, #92] ; 0x5c <== NOT EXECUTED 39a50: eaffffdd b 399cc <rtems_rfs_buffer_handle_release+0xa0> <== NOT EXECUTED
00039a54 <rtems_rfs_buffer_handle_request>:
int
rtems_rfs_buffer_handle_request (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle,
rtems_rfs_buffer_block block,
bool read)
{
39a54: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
39a58: e1a05001 mov r5, r1 <== NOT EXECUTED
/*
* If the handle has a buffer release it. This allows a handle to be reused
* without needing to close then open it again.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
39a5c: e5911008 ldr r1, [r1, #8] <== NOT EXECUTED 39a60: e3510000 cmp r1, #0 <== NOT EXECUTED
int
rtems_rfs_buffer_handle_request (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle,
rtems_rfs_buffer_block block,
bool read)
{
39a64: e1a06000 mov r6, r0 <== NOT EXECUTED 39a68: e1a04002 mov r4, r2 <== NOT EXECUTED 39a6c: e20370ff and r7, r3, #255 ; 0xff <== NOT EXECUTED
/*
* If the handle has a buffer release it. This allows a handle to be reused
* without needing to close then open it again.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
39a70: 0a00000d beq 39aac <rtems_rfs_buffer_handle_request+0x58> <== NOT EXECUTED
{
/*
* Treat block 0 as special to handle the loading of the super block.
*/
if (block && (rtems_rfs_buffer_bnum (handle) == block))
39a74: e3520000 cmp r2, #0 <== NOT EXECUTED
39a78: 0a000003 beq 39a8c <rtems_rfs_buffer_handle_request+0x38> <== NOT EXECUTED
39a7c: e5953004 ldr r3, [r5, #4] <== NOT EXECUTED
39a80: e1530002 cmp r3, r2 <== NOT EXECUTED
39a84: 03a00000 moveq r0, #0 <== NOT EXECUTED
39a88: 08bd85f0 popeq {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_HANDLE_REQUEST))
printf ("rtems-rfs: buffer-request: handle has buffer: %" PRIu32 "\n",
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
39a8c: e1a00006 mov r0, r6 <== NOT EXECUTED 39a90: e1a01005 mov r1, r5 <== NOT EXECUTED 39a94: ebffffa4 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rc > 0)
39a98: e3500000 cmp r0, #0 <== NOT EXECUTED
39a9c: c8bd85f0 popgt {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
return rc;
handle->dirty = false;
39aa0: e3a03000 mov r3, #0 <== NOT EXECUTED
handle->bnum = 0;
39aa4: e5853004 str r3, [r5, #4] <== NOT EXECUTED
rtems_rfs_buffer_bnum (handle));
rc = rtems_rfs_buffer_handle_release (fs, handle);
if (rc > 0)
return rc;
handle->dirty = false;
39aa8: e5c53000 strb r3, [r5] <== NOT EXECUTED
* currently attached to a handle. If it is share the access. A buffer could * be shared where different parts of the block have separate functions. An * example is an inode block and the file system needs to handle 2 inodes in * the same block at the same time. */ if (fs->buffers_count)
39aac: e596104c ldr r1, [r6, #76] ; 0x4c <== NOT EXECUTED 39ab0: e3510000 cmp r1, #0 <== NOT EXECUTED 39ab4: 0595a008 ldreq sl, [r5, #8] <== NOT EXECUTED 39ab8: 0a000005 beq 39ad4 <rtems_rfs_buffer_handle_request+0x80> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return the_chain->last;
39abc: e5968048 ldr r8, [r6, #72] ; 0x48 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
Chain_Control *the_chain
)
{
return (Chain_Node *) the_chain;
39ac0: e2862040 add r2, r6, #64 ; 0x40 <== NOT EXECUTED
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
while (!rtems_chain_is_head (chain, node))
39ac4: e1580002 cmp r8, r2 <== NOT EXECUTED 39ac8: 1a000018 bne 39b30 <rtems_rfs_buffer_handle_request+0xdc> <== NOT EXECUTED 39acc: e3a0a000 mov sl, #0 <== NOT EXECUTED
if (fs->buffers_count)
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
39ad0: e585a008 str sl, [r5, #8] <== NOT EXECUTED
/* * If the buffer has not been found check the local cache of released * buffers. There are release and released modified lists to preserve the * state. */ if (!rtems_rfs_fs_no_local_cache (fs) &&
39ad4: e5963000 ldr r3, [r6] <== NOT EXECUTED 39ad8: e3130002 tst r3, #2 <== NOT EXECUTED 39adc: 1a00003c bne 39bd4 <rtems_rfs_buffer_handle_request+0x180> <== NOT EXECUTED 39ae0: e35a0000 cmp sl, #0 <== NOT EXECUTED 39ae4: 0a00001e beq 39b64 <rtems_rfs_buffer_handle_request+0x110> <== NOT EXECUTED
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
39ae8: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED 39aec: e1a0a001 mov sl, r1 <== NOT EXECUTED
}
/*
* Increase the reference count of the buffer.
*/
rtems_rfs_buffer_refs_up (handle);
39af0: e59a3034 ldr r3, [sl, #52] ; 0x34 <== NOT EXECUTED 39af4: e2833001 add r3, r3, #1 <== NOT EXECUTED 39af8: e58a3034 str r3, [sl, #52] ; 0x34 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
39afc: e2860040 add r0, r6, #64 ; 0x40 <== NOT EXECUTED 39b00: ebff4d5f bl d084 <_Chain_Append> <== NOT EXECUTED
rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle)); fs->buffers_count++;
39b04: e596204c ldr r2, [r6, #76] ; 0x4c <== NOT EXECUTED
handle->buffer->user = (void*) ((intptr_t) block);
39b08: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
/* * Increase the reference count of the buffer. */ rtems_rfs_buffer_refs_up (handle); rtems_chain_append (&fs->buffers, rtems_rfs_buffer_link (handle)); fs->buffers_count++;
39b0c: e2822001 add r2, r2, #1 <== NOT EXECUTED 39b10: e586204c str r2, [r6, #76] ; 0x4c <== NOT EXECUTED
handle->buffer->user = (void*) ((intptr_t) block);
39b14: e5834038 str r4, [r3, #56] ; 0x38 <== NOT EXECUTED
handle->bnum = block;
39b18: e5854004 str r4, [r5, #4] <== NOT EXECUTED 39b1c: e3a00000 mov r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: buffer-request: block=%" PRIu32 " bdbuf-%s=%" PRIu32 " refs=%d\n",
block, read ? "read" : "get", handle->buffer->block,
handle->buffer->references);
return 0;
}
39b20: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(
Chain_Node *the_node
)
{
return the_node->previous;
39b24: e5988004 ldr r8, [r8, #4] <== NOT EXECUTED
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
while (!rtems_chain_is_head (chain, node))
39b28: e1580002 cmp r8, r2 <== NOT EXECUTED 39b2c: 0affffe6 beq 39acc <rtems_rfs_buffer_handle_request+0x78> <== NOT EXECUTED
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
39b30: e5983038 ldr r3, [r8, #56] ; 0x38 <== NOT EXECUTED 39b34: e1530004 cmp r3, r4 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
39b38: e1a0a008 mov sl, r8 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
39b3c: 1afffff8 bne 39b24 <rtems_rfs_buffer_handle_request+0xd0> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf (": found block=%" PRIuPTR "\n",
((intptr_t)(buffer->user)));
(*count)--;
39b40: e2411001 sub r1, r1, #1 <== NOT EXECUTED 39b44: e586104c str r1, [r6, #76] ; 0x4c <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
39b48: e1a00008 mov r0, r8 <== NOT EXECUTED 39b4c: ebff4d57 bl d0b0 <_Chain_Extract> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
39b50: e3a03000 mov r3, #0 <== NOT EXECUTED 39b54: e5883000 str r3, [r8] <== NOT EXECUTED 39b58: e5883004 str r3, [r8, #4] <== NOT EXECUTED
if (fs->buffers_count)
{
/*
* Check the active buffer list for shared buffers.
*/
handle->buffer = rtems_rfs_scan_chain (&fs->buffers,
39b5c: e585a008 str sl, [r5, #8] <== NOT EXECUTED 39b60: eaffffdb b 39ad4 <rtems_rfs_buffer_handle_request+0x80> <== NOT EXECUTED
!rtems_rfs_buffer_handle_has_block (handle))
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
39b64: e596105c ldr r1, [r6, #92] ; 0x5c <== NOT EXECUTED 39b68: e3510000 cmp r1, #0 <== NOT EXECUTED 39b6c: 1a000028 bne 39c14 <rtems_rfs_buffer_handle_request+0x1c0> <== NOT EXECUTED
handle->buffer = rtems_rfs_scan_chain (&fs->release,
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
fs->release_modified_count)
39b70: e596106c ldr r1, [r6, #108] ; 0x6c <== NOT EXECUTED
if (fs->release_count)
handle->buffer = rtems_rfs_scan_chain (&fs->release,
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
39b74: e3510000 cmp r1, #0 <== NOT EXECUTED 39b78: 0a000018 beq 39be0 <rtems_rfs_buffer_handle_request+0x18c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return the_chain->last;
39b7c: e5968068 ldr r8, [r6, #104] ; 0x68 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
Chain_Control *the_chain
)
{
return (Chain_Node *) the_chain;
39b80: e2862060 add r2, r6, #96 ; 0x60 <== NOT EXECUTED
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
while (!rtems_chain_is_head (chain, node))
39b84: e1580002 cmp r8, r2 <== NOT EXECUTED 39b88: 1a000003 bne 39b9c <rtems_rfs_buffer_handle_request+0x148> <== NOT EXECUTED 39b8c: ea000039 b 39c78 <rtems_rfs_buffer_handle_request+0x224> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(
Chain_Node *the_node
)
{
return the_node->previous;
39b90: e5988004 ldr r8, [r8, #4] <== NOT EXECUTED 39b94: e1520008 cmp r2, r8 <== NOT EXECUTED 39b98: 0a000036 beq 39c78 <rtems_rfs_buffer_handle_request+0x224> <== NOT EXECUTED
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
39b9c: e5983038 ldr r3, [r8, #56] ; 0x38 <== NOT EXECUTED 39ba0: e1530004 cmp r3, r4 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
while (!rtems_chain_is_head (chain, node))
{
buffer = (rtems_rfs_buffer*) node;
39ba4: e1a0a008 mov sl, r8 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
39ba8: 1afffff8 bne 39b90 <rtems_rfs_buffer_handle_request+0x13c> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf (": found block=%" PRIuPTR "\n",
((intptr_t)(buffer->user)));
(*count)--;
39bac: e2411001 sub r1, r1, #1 <== NOT EXECUTED 39bb0: e586106c str r1, [r6, #108] ; 0x6c <== NOT EXECUTED 39bb4: e1a00008 mov r0, r8 <== NOT EXECUTED 39bb8: ebff4d3c bl d0b0 <_Chain_Extract> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
39bbc: e3a03000 mov r3, #0 <== NOT EXECUTED
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
rtems_rfs_buffer_mark_dirty (handle);
39bc0: e3a02001 mov r2, #1 <== NOT EXECUTED 39bc4: e5883000 str r3, [r8] <== NOT EXECUTED
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
39bc8: e5858008 str r8, [r5, #8] <== NOT EXECUTED
block);
/*
* If we found a buffer retain the dirty buffer state.
*/
if (rtems_rfs_buffer_handle_has_block (handle))
rtems_rfs_buffer_mark_dirty (handle);
39bcc: e5c52000 strb r2, [r5] <== NOT EXECUTED 39bd0: e5883004 str r3, [r8, #4] <== NOT EXECUTED
}
/*
* If not located we request the buffer from the I/O layer.
*/
if (!rtems_rfs_buffer_handle_has_block (handle))
39bd4: e35a0000 cmp sl, #0 <== NOT EXECUTED 39bd8: 15951008 ldrne r1, [r5, #8] <== NOT EXECUTED 39bdc: 1affffc3 bne 39af0 <rtems_rfs_buffer_handle_request+0x9c> <== NOT EXECUTED
{
rc = rtems_rfs_buffer_io_request (fs, block, read, &handle->buffer);
39be0: e1a01004 mov r1, r4 <== NOT EXECUTED 39be4: e2853008 add r3, r5, #8 <== NOT EXECUTED 39be8: e1a02007 mov r2, r7 <== NOT EXECUTED 39bec: e1a00006 mov r0, r6 <== NOT EXECUTED 39bf0: eb002398 bl 42a58 <rtems_rfs_buffer_bdbuf_request> <== NOT EXECUTED
rtems_chain_set_off_chain (rtems_rfs_buffer_link(handle));
39bf4: e5951008 ldr r1, [r5, #8] <== NOT EXECUTED 39bf8: e3a03000 mov r3, #0 <== NOT EXECUTED
if (rc > 0)
39bfc: e3500000 cmp r0, #0 <== NOT EXECUTED
39c00: e5813000 str r3, [r1] <== NOT EXECUTED
39c04: e5813004 str r3, [r1, #4] <== NOT EXECUTED
39c08: c8bd85f0 popgt {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
39c0c: e1a0a001 mov sl, r1 <== NOT EXECUTED
39c10: eaffffb6 b 39af0 <rtems_rfs_buffer_handle_request+0x9c> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Last(
Chain_Control *the_chain
)
{
return the_chain->last;
39c14: e5968058 ldr r8, [r6, #88] ; 0x58 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Head(
Chain_Control *the_chain
)
{
return (Chain_Node *) the_chain;
39c18: e2862050 add r2, r6, #80 ; 0x50 <== NOT EXECUTED
node = rtems_chain_last (chain);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: buffer-scan: count=%" PRIu32 ", block=%" PRIu32 ": ", *count, block);
while (!rtems_chain_is_head (chain, node))
39c1c: e1580002 cmp r8, r2 <== NOT EXECUTED 39c20: 1a000003 bne 39c34 <rtems_rfs_buffer_handle_request+0x1e0> <== NOT EXECUTED 39c24: ea000010 b 39c6c <rtems_rfs_buffer_handle_request+0x218> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Previous(
Chain_Node *the_node
)
{
return the_node->previous;
39c28: e5988004 ldr r8, [r8, #4] <== NOT EXECUTED 39c2c: e1580002 cmp r8, r2 <== NOT EXECUTED 39c30: 0a00000d beq 39c6c <rtems_rfs_buffer_handle_request+0x218> <== NOT EXECUTED
buffer = (rtems_rfs_buffer*) node;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("%" PRIuPTR " ", ((intptr_t) buffer->user));
if (((rtems_rfs_buffer_block) ((intptr_t)(buffer->user))) == block)
39c34: e5983038 ldr r3, [r8, #56] ; 0x38 <== NOT EXECUTED 39c38: e1530004 cmp r3, r4 <== NOT EXECUTED 39c3c: 1afffff9 bne 39c28 <rtems_rfs_buffer_handle_request+0x1d4> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf (": found block=%" PRIuPTR "\n",
((intptr_t)(buffer->user)));
(*count)--;
39c40: e2411001 sub r1, r1, #1 <== NOT EXECUTED 39c44: e586105c str r1, [r6, #92] ; 0x5c <== NOT EXECUTED 39c48: e1a00008 mov r0, r8 <== NOT EXECUTED 39c4c: ebff4d17 bl d0b0 <_Chain_Extract> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Set_off_chain(
Chain_Node *node
)
{
node->next = node->previous = NULL;
39c50: e3a03000 mov r3, #0 <== NOT EXECUTED
if (fs->release_count)
handle->buffer = rtems_rfs_scan_chain (&fs->release,
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
39c54: e3580000 cmp r8, #0 <== NOT EXECUTED 39c58: e5883000 str r3, [r8] <== NOT EXECUTED 39c5c: e5883004 str r3, [r8, #4] <== NOT EXECUTED
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
handle->buffer = rtems_rfs_scan_chain (&fs->release,
39c60: e5858008 str r8, [r5, #8] <== NOT EXECUTED
&fs->release_count,
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
39c64: 1affff9f bne 39ae8 <rtems_rfs_buffer_handle_request+0x94> <== NOT EXECUTED 39c68: eaffffc0 b 39b70 <rtems_rfs_buffer_handle_request+0x11c> <== NOT EXECUTED
{
/*
* Check the local cache of released buffers.
*/
if (fs->release_count)
handle->buffer = rtems_rfs_scan_chain (&fs->release,
39c6c: e3a03000 mov r3, #0 <== NOT EXECUTED 39c70: e5853008 str r3, [r5, #8] <== NOT EXECUTED 39c74: eaffffbd b 39b70 <rtems_rfs_buffer_handle_request+0x11c> <== NOT EXECUTED
block);
if (!rtems_rfs_buffer_handle_has_block (handle) &&
fs->release_modified_count)
{
handle->buffer = rtems_rfs_scan_chain (&fs->release_modified,
39c78: e3a03000 mov r3, #0 <== NOT EXECUTED 39c7c: e5853008 str r3, [r5, #8] <== NOT EXECUTED 39c80: eaffffd6 b 39be0 <rtems_rfs_buffer_handle_request+0x18c> <== NOT EXECUTED
000398d0 <rtems_rfs_buffer_open>:
return rc;
}
int
rtems_rfs_buffer_open (const char* name, rtems_rfs_file_system* fs)
{
398d0: e92d4010 push {r4, lr} <== NOT EXECUTED
398d4: e24dd048 sub sp, sp, #72 ; 0x48 <== NOT EXECUTED
398d8: e1a04001 mov r4, r1 <== NOT EXECUTED
struct stat st;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-open: opening: %s\n", name);
if (stat (name, &st) < 0)
398dc: e1a0100d mov r1, sp <== NOT EXECUTED 398e0: ebff3f54 bl 9638 <stat> <== NOT EXECUTED 398e4: e3500000 cmp r0, #0 <== NOT EXECUTED 398e8: b3a00002 movlt r0, #2 <== NOT EXECUTED 398ec: ba000004 blt 39904 <rtems_rfs_buffer_open+0x34> <== NOT EXECUTED
#if RTEMS_RFS_USE_LIBBLOCK
/*
* Is the device a block device ?
*/
if (!S_ISBLK (st.st_mode))
398f0: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 398f4: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED 398f8: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED 398fc: 0a000002 beq 3990c <rtems_rfs_buffer_open+0x3c> <== NOT EXECUTED
/*
* Check that device is registred as a block device and lock it.
*/
fs->disk = rtems_disk_obtain (st.st_rdev);
if (!fs->disk)
39900: e3a00005 mov r0, #5 <== NOT EXECUTED
printf ("rtems-rfs: buffer-open: blks=%" PRId32 ", blk-size=%" PRId32 "\n",
rtems_rfs_fs_media_blocks (fs),
rtems_rfs_fs_media_block_size (fs));
return 0;
}
39904: e28dd048 add sp, sp, #72 ; 0x48 <== NOT EXECUTED
39908: e8bd8010 pop {r4, pc} <== NOT EXECUTED
}
/*
* Check that device is registred as a block device and lock it.
*/
fs->disk = rtems_disk_obtain (st.st_rdev);
3990c: e28d1018 add r1, sp, #24 <== NOT EXECUTED
39910: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
39914: ebff33b0 bl 67dc <rtems_disk_obtain> <== NOT EXECUTED
if (!fs->disk)
39918: e3500000 cmp r0, #0 <== NOT EXECUTED
}
/*
* Check that device is registred as a block device and lock it.
*/
fs->disk = rtems_disk_obtain (st.st_rdev);
3991c: e584000c str r0, [r4, #12] <== NOT EXECUTED
if (!fs->disk)
39920: 13a00000 movne r0, #0 <== NOT EXECUTED 39924: 1afffff6 bne 39904 <rtems_rfs_buffer_open+0x34> <== NOT EXECUTED 39928: eafffff4 b 39900 <rtems_rfs_buffer_open+0x30> <== NOT EXECUTED
0003984c <rtems_rfs_buffer_setblksize>:
int
rtems_rfs_buffer_setblksize (rtems_rfs_file_system* fs, size_t size)
{
3984c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
39850: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
39854: e1a05000 mov r5, r0 <== NOT EXECUTED
39858: e28d4004 add r4, sp, #4 <== NOT EXECUTED
3985c: e5241004 str r1, [r4, #-4]! <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: block size: %zu\n", size);
rc = rtems_rfs_buffers_release (fs);
39860: ebffffdb bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: buffer release failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_buffer_sync (fs);
39864: e1a00005 mov r0, r5 <== NOT EXECUTED 39868: ebffffeb bl 3981c <rtems_rfs_buffer_sync> <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SETBLKSIZE))
printf ("rtems-rfs: buffer-setblksize: device sync failed: %d: %s\n",
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
3986c: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 39870: e3a01102 mov r1, #-2147483648 ; 0x80000000 <== NOT EXECUTED 39874: e2811911 add r1, r1, #278528 ; 0x44000 <== NOT EXECUTED 39878: e2811f81 add r1, r1, #516 ; 0x204 <== NOT EXECUTED 3987c: e1a0200d mov r2, sp <== NOT EXECUTED 39880: e1a00003 mov r0, r3 <== NOT EXECUTED 39884: e1a0e00f mov lr, pc <== NOT EXECUTED 39888: e593f028 ldr pc, [r3, #40] ; 0x28 <== NOT EXECUTED
if (rc < 0)
3988c: e3500000 cmp r0, #0 <== NOT EXECUTED 39890: ba000001 blt 3989c <rtems_rfs_buffer_setblksize+0x50> <== NOT EXECUTED
rc = errno;
#endif
return rc;
}
39894: e28dd004 add sp, sp, #4 <== NOT EXECUTED
39898: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
rc, strerror (rc));
#if RTEMS_RFS_USE_LIBBLOCK
rc = fs->disk->ioctl (fs->disk, RTEMS_BLKIO_SETBLKSIZE, &size);
if (rc < 0)
rc = errno;
3989c: eb0025d3 bl 42ff0 <__errno> <== NOT EXECUTED 398a0: e5900000 ldr r0, [r0] <== NOT EXECUTED 398a4: eafffffa b 39894 <rtems_rfs_buffer_setblksize+0x48> <== NOT EXECUTED
0003981c <rtems_rfs_buffer_sync>:
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
3981c: e590300c ldr r3, [r0, #12] <== NOT EXECUTED
return rc;
}
int
rtems_rfs_buffer_sync (rtems_rfs_file_system* fs)
{
39820: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
39824: e1a04000 mov r4, r0 <== NOT EXECUTED
/*
* @todo Split in the separate files for each type.
*/
#if RTEMS_RFS_USE_LIBBLOCK
sc = rtems_bdbuf_syncdev (rtems_rfs_fs_device (fs));
39828: e8930003 ldm r3, {r0, r1} <== NOT EXECUTED
3982c: ebff2877 bl 3a10 <rtems_bdbuf_syncdev> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
39830: e3500000 cmp r0, #0 <== NOT EXECUTED 39834: 13a05005 movne r5, #5 <== NOT EXECUTED 39838: 03a05000 moveq r5, #0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_SYNC))
printf ("rtems-rfs: buffer-sync: device sync failed: %s\n",
rtems_status_text (sc));
result = EIO;
}
rtems_disk_release (fs->disk);
3983c: e594000c ldr r0, [r4, #12] <== NOT EXECUTED 39840: ebff3479 bl 6a2c <rtems_disk_release> <== NOT EXECUTED
printf ("rtems-rfs: buffer-sync: file sync failed: %d: %s\n",
result, strerror (result));
}
#endif
return result;
}
39844: e1a00005 mov r0, r5 <== NOT EXECUTED
39848: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
000397d4 <rtems_rfs_buffers_release>:
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
397d4: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
397d8: e280105c add r1, r0, #92 ; 0x5c <== NOT EXECUTED
return rrc;
}
int
rtems_rfs_buffers_release (rtems_rfs_file_system* fs)
{
397dc: e1a04000 mov r4, r0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
397e0: e3a02000 mov r2, #0 <== NOT EXECUTED 397e4: e2800050 add r0, r0, #80 ; 0x50 <== NOT EXECUTED 397e8: ebffffdd bl 39764 <rtems_rfs_release_chain> <== NOT EXECUTED
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
397ec: e284106c add r1, r4, #108 ; 0x6c <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_RELEASE))
printf ("rtems-rfs: buffers-release: active:%" PRIu32 " "
"release:%" PRIu32 " release-modified:%" PRIu32 "\n",
fs->buffers_count, fs->release_count, fs->release_modified_count);
rc = rtems_rfs_release_chain (&fs->release,
397f0: e1c05fc0 bic r5, r0, r0, asr #31 <== NOT EXECUTED
&fs->release_count,
false);
if ((rc > 0) && (rrc == 0))
rrc = rc;
rc = rtems_rfs_release_chain (&fs->release_modified,
397f4: e3a02001 mov r2, #1 <== NOT EXECUTED 397f8: e2840060 add r0, r4, #96 ; 0x60 <== NOT EXECUTED 397fc: ebffffd8 bl 39764 <rtems_rfs_release_chain> <== NOT EXECUTED
&fs->release_modified_count,
true);
if ((rc > 0) && (rrc == 0))
39800: e2753001 rsbs r3, r5, #1 <== NOT EXECUTED 39804: 33a03000 movcc r3, #0 <== NOT EXECUTED 39808: e3500000 cmp r0, #0 <== NOT EXECUTED 3980c: d3a03000 movle r3, #0 <== NOT EXECUTED
rrc = rc;
return rrc;
}
39810: e3530000 cmp r3, #0 <== NOT EXECUTED
39814: 01a00005 moveq r0, r5 <== NOT EXECUTED
39818: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
0003a288 <rtems_rfs_dir_add_entry>:
rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
const char* name,
size_t length,
rtems_rfs_ino ino)
{
3a288: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3a28c: e24dd098 sub sp, sp, #152 ; 0x98 <== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%zd\n", length);
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
3a290: e28d602c add r6, sp, #44 ; 0x2c <== NOT EXECUTED
rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
const char* name,
size_t length,
rtems_rfs_ino ino)
{
3a294: e58d2008 str r2, [sp, #8] <== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%zd\n", length);
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
3a298: e1a02006 mov r2, r6 <== NOT EXECUTED
rtems_rfs_dir_add_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
const char* name,
size_t length,
rtems_rfs_ino ino)
{
3a29c: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3a2a0: e1a04000 mov r4, r0 <== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%zd\n", length);
}
rc = rtems_rfs_block_map_open (fs, dir, &map);
3a2a4: ebfffcd5 bl 39600 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
3a2a8: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3a2ac: da000002 ble 3a2bc <rtems_rfs_dir_add_entry+0x34> <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
3a2b0: e1a00009 mov r0, r9 <== NOT EXECUTED
3a2b4: e28dd098 add sp, sp, #152 ; 0x98 <== NOT EXECUTED
3a2b8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
3a2bc: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a2c0: e3a00801 mov r0, #65536 ; 0x10000 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
3a2c4: e3a03000 mov r3, #0 <== NOT EXECUTED 3a2c8: e2400001 sub r0, r0, #1 <== NOT EXECUTED
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
3a2cc: e281100a add r1, r1, #10 <== NOT EXECUTED 3a2d0: e58d3090 str r3, [sp, #144] ; 0x90 <== NOT EXECUTED 3a2d4: e5cd307c strb r3, [sp, #124] ; 0x7c <== NOT EXECUTED
handle->bnum = 0;
3a2d8: e58d3080 str r3, [sp, #128] ; 0x80 <== NOT EXECUTED
handle->buffer = NULL;
3a2dc: e58d3084 str r3, [sp, #132] ; 0x84 <== NOT EXECUTED
* @param bpos A pointer to the block position.
*/
static inline void
rtems_rfs_block_set_bpos_zero (rtems_rfs_block_pos* bpos)
{
bpos->bno = 0;
3a2e0: e58d3088 str r3, [sp, #136] ; 0x88 <== NOT EXECUTED
bpos->boff = 0;
3a2e4: e58d308c str r3, [sp, #140] ; 0x8c <== NOT EXECUTED
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a2e8: e58d0000 str r0, [sp] <== NOT EXECUTED 3a2ec: e28da088 add sl, sp, #136 ; 0x88 <== NOT EXECUTED 3a2f0: e28d7094 add r7, sp, #148 ; 0x94 <== NOT EXECUTED 3a2f4: e28d807c add r8, sp, #124 ; 0x7c <== NOT EXECUTED
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
3a2f8: e58d101c str r1, [sp, #28] <== NOT EXECUTED 3a2fc: ea000002 b 3a30c <rtems_rfs_dir_add_entry+0x84> <== NOT EXECUTED
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a300: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3a304: e253200a subs r2, r3, #10 <== NOT EXECUTED 3a308: 1a000026 bne 3a3a8 <rtems_rfs_dir_add_entry+0x120> <== NOT EXECUTED
/*
* Locate the first block. If an error the block will be 0. If the map is
* empty which happens when creating a directory and adding the first entry
* the seek will return ENXIO. In this case we need to grow the directory.
*/
rc = rtems_rfs_block_map_find (fs, &map, &bpos, &block);
3a30c: e1a00004 mov r0, r4 <== NOT EXECUTED 3a310: e1a01006 mov r1, r6 <== NOT EXECUTED 3a314: e1a0200a mov r2, sl <== NOT EXECUTED 3a318: e1a03007 mov r3, r7 <== NOT EXECUTED 3a31c: ebfff995 bl 38978 <rtems_rfs_block_map_find> <== NOT EXECUTED
if (rc > 0)
3a320: e3500000 cmp r0, #0 <== NOT EXECUTED 3a324: d3a05001 movle r5, #1 <== NOT EXECUTED 3a328: da000009 ble 3a354 <rtems_rfs_dir_add_entry+0xcc> <== NOT EXECUTED
{
if (rc != ENXIO)
3a32c: e3500006 cmp r0, #6 <== NOT EXECUTED 3a330: 1a000062 bne 3a4c0 <rtems_rfs_dir_add_entry+0x238> <== NOT EXECUTED
}
/*
* We have reached the end of the directory so add a block.
*/
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
3a334: e1a00004 mov r0, r4 <== NOT EXECUTED 3a338: e1a01006 mov r1, r6 <== NOT EXECUTED 3a33c: e3a02001 mov r2, #1 <== NOT EXECUTED 3a340: e1a03007 mov r3, r7 <== NOT EXECUTED 3a344: ebfffb41 bl 39050 <rtems_rfs_block_map_grow> <== NOT EXECUTED
if (rc > 0)
3a348: e3500000 cmp r0, #0 <== NOT EXECUTED 3a34c: ca00005b bgt 3a4c0 <rtems_rfs_dir_add_entry+0x238> <== NOT EXECUTED 3a350: e3a05000 mov r5, #0 <== NOT EXECUTED
}
read = false;
}
bpos.bno++;
3a354: e59dc088 ldr ip, [sp, #136] ; 0x88 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
3a358: e1a00004 mov r0, r4 <== NOT EXECUTED
}
read = false;
}
bpos.bno++;
3a35c: e28cc001 add ip, ip, #1 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
3a360: e1a01008 mov r1, r8 <== NOT EXECUTED 3a364: e59d2094 ldr r2, [sp, #148] ; 0x94 <== NOT EXECUTED 3a368: e1a03005 mov r3, r5 <== NOT EXECUTED
}
read = false;
}
bpos.bno++;
3a36c: e58dc088 str ip, [sp, #136] ; 0x88 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, read);
3a370: ebfffdb7 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
3a374: e3500000 cmp r0, #0 <== NOT EXECUTED 3a378: ca000050 bgt 3a4c0 <rtems_rfs_dir_add_entry+0x238> <== NOT EXECUTED
"block buffer req failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
break;
}
entry = rtems_rfs_buffer_data (&buffer);
3a37c: e59d3084 ldr r3, [sp, #132] ; 0x84 <== NOT EXECUTED
if (!read)
3a380: e3550000 cmp r5, #0 <== NOT EXECUTED
"block buffer req failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
break;
}
entry = rtems_rfs_buffer_data (&buffer);
3a384: e5935020 ldr r5, [r3, #32] <== NOT EXECUTED
if (!read)
3a388: 1affffdc bne 3a300 <rtems_rfs_dir_add_entry+0x78> <== NOT EXECUTED
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
3a38c: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 3a390: e1a00005 mov r0, r5 <== NOT EXECUTED 3a394: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED 3a398: eb00304b bl 464cc <memset> <== NOT EXECUTED
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a39c: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 3a3a0: e253200a subs r2, r3, #10 <== NOT EXECUTED 3a3a4: 0affffd8 beq 3a30c <rtems_rfs_dir_add_entry+0x84> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
3a3a8: e5d50008 ldrb r0, [r5, #8] <== NOT EXECUTED 3a3ac: e5d51009 ldrb r1, [r5, #9] <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a3b0: e59d9000 ldr r9, [sp] <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
3a3b4: e285c008 add ip, r5, #8 <== NOT EXECUTED 3a3b8: e285e009 add lr, r5, #9 <== NOT EXECUTED 3a3bc: e58dc018 str ip, [sp, #24] <== NOT EXECUTED 3a3c0: e58de014 str lr, [sp, #20] <== NOT EXECUTED 3a3c4: e1811400 orr r1, r1, r0, lsl #8 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a3c8: e1510009 cmp r1, r9 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
3a3cc: e285c002 add ip, r5, #2 <== NOT EXECUTED 3a3d0: e1a09005 mov r9, r5 <== NOT EXECUTED 3a3d4: e5d50001 ldrb r0, [r5, #1] <== NOT EXECUTED 3a3d8: e4d9b001 ldrb fp, [r9], #1 <== NOT EXECUTED 3a3dc: e58dc010 str ip, [sp, #16] <== NOT EXECUTED 3a3e0: e285e003 add lr, r5, #3 <== NOT EXECUTED 3a3e4: e5d5c002 ldrb ip, [r5, #2] <== NOT EXECUTED 3a3e8: e58de00c str lr, [sp, #12] <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a3ec: 03a00000 moveq r0, #0 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
3a3f0: e5d5e003 ldrb lr, [r5, #3] <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a3f4: 0a000046 beq 3a514 <rtems_rfs_dir_add_entry+0x28c> <== NOT EXECUTED
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
3a3f8: e351000a cmp r1, #10 <== NOT EXECUTED 3a3fc: da00003b ble 3a4f0 <rtems_rfs_dir_add_entry+0x268> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
3a400: e18eec0b orr lr, lr, fp, lsl #24 <== NOT EXECUTED 3a404: e18ee40c orr lr, lr, ip, lsl #8 <== NOT EXECUTED 3a408: e594b018 ldr fp, [r4, #24] <== NOT EXECUTED 3a40c: e18e0800 orr r0, lr, r0, lsl #16 <== NOT EXECUTED 3a410: e3a0e000 mov lr, #0 <== NOT EXECUTED
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
3a414: e3500000 cmp r0, #0 <== NOT EXECUTED 3a418: 1151000b cmpne r1, fp <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
offset += elength;
3a41c: e08ee001 add lr, lr, r1 <== NOT EXECUTED
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
3a420: 2a000032 bcs 3a4f0 <rtems_rfs_dir_add_entry+0x268> <== NOT EXECUTED 3a424: e594c010 ldr ip, [r4, #16] <== NOT EXECUTED 3a428: e15c0000 cmp ip, r0 <== NOT EXECUTED 3a42c: 3a00002f bcc 3a4f0 <rtems_rfs_dir_add_entry+0x268> <== NOT EXECUTED
if (!read)
memset (entry, 0xff, rtems_rfs_fs_block_size (fs));
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a430: e15e0002 cmp lr, r2 <== NOT EXECUTED 3a434: e1a0000e mov r0, lr <== NOT EXECUTED 3a438: 2affffb3 bcs 3a30c <rtems_rfs_dir_add_entry+0x84> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return EIO;
}
entry += elength;
3a43c: e0855001 add r5, r5, r1 <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
3a440: e5d5c008 ldrb ip, [r5, #8] <== NOT EXECUTED 3a444: e5d51009 ldrb r1, [r5, #9] <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a448: e59d9000 ldr r9, [sp] <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
3a44c: e181140c orr r1, r1, ip, lsl #8 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a450: e1510009 cmp r1, r9 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
3a454: e1a09005 mov r9, r5 <== NOT EXECUTED 3a458: e4d9c001 ldrb ip, [r9], #1 <== NOT EXECUTED 3a45c: e58dc028 str ip, [sp, #40] ; 0x28 <== NOT EXECUTED 3a460: e5d5c001 ldrb ip, [r5, #1] <== NOT EXECUTED 3a464: e58dc024 str ip, [sp, #36] ; 0x24 <== NOT EXECUTED 3a468: e5d5c002 ldrb ip, [r5, #2] <== NOT EXECUTED 3a46c: e58dc020 str ip, [sp, #32] <== NOT EXECUTED 3a470: e5d5c003 ldrb ip, [r5, #3] <== NOT EXECUTED 3a474: e58dc00c str ip, [sp, #12] <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
3a478: e285c008 add ip, r5, #8 <== NOT EXECUTED 3a47c: e58dc018 str ip, [sp, #24] <== NOT EXECUTED 3a480: e285c009 add ip, r5, #9 <== NOT EXECUTED 3a484: e58dc014 str ip, [sp, #20] <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
3a488: e285c002 add ip, r5, #2 <== NOT EXECUTED 3a48c: e58dc010 str ip, [sp, #16] <== NOT EXECUTED 3a490: e285c003 add ip, r5, #3 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a494: 0a00001d beq 3a510 <rtems_rfs_dir_add_entry+0x288> <== NOT EXECUTED
}
break;
}
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
3a498: e351000a cmp r1, #10 <== NOT EXECUTED 3a49c: da000013 ble 3a4f0 <rtems_rfs_dir_add_entry+0x268> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
3a4a0: e59d900c ldr r9, [sp, #12] <== NOT EXECUTED 3a4a4: e59dc028 ldr ip, [sp, #40] ; 0x28 <== NOT EXECUTED 3a4a8: e1890c0c orr r0, r9, ip, lsl #24 <== NOT EXECUTED 3a4ac: e59d9024 ldr r9, [sp, #36] ; 0x24 <== NOT EXECUTED 3a4b0: e59dc020 ldr ip, [sp, #32] <== NOT EXECUTED 3a4b4: e1800809 orr r0, r0, r9, lsl #16 <== NOT EXECUTED 3a4b8: e180040c orr r0, r0, ip, lsl #8 <== NOT EXECUTED 3a4bc: eaffffd4 b 3a414 <rtems_rfs_dir_add_entry+0x18c> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3a4c0: e1a01008 mov r1, r8 <== NOT EXECUTED 3a4c4: e1a09000 mov r9, r0 <== NOT EXECUTED 3a4c8: e1a00004 mov r0, r4 <== NOT EXECUTED 3a4cc: ebfffd16 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
3a4d0: e3a03000 mov r3, #0 <== NOT EXECUTED
offset += elength;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
3a4d4: e1a00004 mov r0, r4 <== NOT EXECUTED 3a4d8: e1a01006 mov r1, r6 <== NOT EXECUTED
handle->bnum = 0; handle->buffer = NULL;
3a4dc: e58d3084 str r3, [sp, #132] ; 0x84 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3a4e0: e5cd307c strb r3, [sp, #124] ; 0x7c <== NOT EXECUTED
handle->bnum = 0;
3a4e4: e58d3080 str r3, [sp, #128] ; 0x80 <== NOT EXECUTED 3a4e8: ebfffbd1 bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
3a4ec: eaffff6f b 3a2b0 <rtems_rfs_dir_add_entry+0x28> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_ADD_ENTRY))
printf ("rtems-rfs: dir-add-entry: "
"bad length or ino for ino %" PRIu32 ": %u/%" PRId32 " @ %04x\n",
rtems_rfs_inode_ino (dir), elength, eino, offset);
rtems_rfs_buffer_handle_close (fs, &buffer);
3a4f0: e1a01008 mov r1, r8 <== NOT EXECUTED 3a4f4: e1a00004 mov r0, r4 <== NOT EXECUTED 3a4f8: ebfffde1 bl 39c84 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
3a4fc: e1a00004 mov r0, r4 <== NOT EXECUTED 3a500: e1a01006 mov r1, r6 <== NOT EXECUTED 3a504: ebfffbca bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED 3a508: e3a09005 mov r9, #5 <== NOT EXECUTED
return EIO;
3a50c: eaffff67 b 3a2b0 <rtems_rfs_dir_add_entry+0x28> <== NOT EXECUTED 3a510: e58dc00c str ip, [sp, #12] <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
3a514: e59de01c ldr lr, [sp, #28] <== NOT EXECUTED 3a518: e0603003 rsb r3, r0, r3 <== NOT EXECUTED 3a51c: e15e0003 cmp lr, r3 <== NOT EXECUTED 3a520: 2affff79 bcs 3a30c <rtems_rfs_dir_add_entry+0x84> <== NOT EXECUTED
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
3a524: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 3a528: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 3a52c: eb002159 bl 42a98 <rtems_rfs_dir_hash> <== NOT EXECUTED
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
3a530: e59d70bc ldr r7, [sp, #188] ; 0xbc <== NOT EXECUTED 3a534: e1a0c005 mov ip, r5 <== NOT EXECUTED
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
3a538: e1a02c20 lsr r2, r0, #24 <== NOT EXECUTED 3a53c: e1a01820 lsr r1, r0, #16 <== NOT EXECUTED 3a540: e1a0e420 lsr lr, r0, #8 <== NOT EXECUTED
rtems_rfs_dir_set_entry_ino (entry, ino);
3a544: e1a03c27 lsr r3, r7, #24 <== NOT EXECUTED
if ((length + RTEMS_RFS_DIR_ENTRY_SIZE) <
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
3a548: e5c52004 strb r2, [r5, #4] <== NOT EXECUTED 3a54c: e5c51005 strb r1, [r5, #5] <== NOT EXECUTED 3a550: e5c50007 strb r0, [r5, #7] <== NOT EXECUTED 3a554: e5c5e006 strb lr, [r5, #6] <== NOT EXECUTED
rtems_rfs_dir_set_entry_ino (entry, ino);
3a558: e1a01827 lsr r1, r7, #16 <== NOT EXECUTED 3a55c: e4cc300a strb r3, [ip], #10 <== NOT EXECUTED
rtems_rfs_dir_set_entry_length (entry,
3a560: e59de01c ldr lr, [sp, #28] <== NOT EXECUTED
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
3a564: e1a02427 lsr r2, r7, #8 <== NOT EXECUTED
rtems_rfs_dir_set_entry_length (entry,
3a568: e59d7004 ldr r7, [sp, #4] <== NOT EXECUTED
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
3a56c: e5c91000 strb r1, [r9] <== NOT EXECUTED 3a570: e59d9010 ldr r9, [sp, #16] <== NOT EXECUTED 3a574: e5c92000 strb r2, [r9] <== NOT EXECUTED 3a578: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED
rtems_rfs_dir_set_entry_length (entry,
3a57c: e1a0042e lsr r0, lr, #8 <== NOT EXECUTED
(rtems_rfs_fs_block_size (fs) - offset))
{
uint32_t hash;
hash = rtems_rfs_dir_hash (name, length);
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
3a580: e59de0bc ldr lr, [sp, #188] ; 0xbc <== NOT EXECUTED 3a584: e5c1e000 strb lr, [r1] <== NOT EXECUTED
rtems_rfs_dir_set_entry_length (entry,
3a588: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 3a58c: e5c20000 strb r0, [r2] <== NOT EXECUTED 3a590: e287300a add r3, r7, #10 <== NOT EXECUTED 3a594: e59d7014 ldr r7, [sp, #20] <== NOT EXECUTED 3a598: e5c73000 strb r3, [r7] <== NOT EXECUTED
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
3a59c: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 3a5a0: e1a0000c mov r0, ip <== NOT EXECUTED 3a5a4: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 3a5a8: eb002f40 bl 462b0 <memcpy> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&buffer);
3a5ac: e3a03001 mov r3, #1 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
3a5b0: e1a01008 mov r1, r8 <== NOT EXECUTED 3a5b4: e1a00004 mov r0, r4 <== NOT EXECUTED
rtems_rfs_dir_set_entry_hash (entry, hash);
rtems_rfs_dir_set_entry_ino (entry, ino);
rtems_rfs_dir_set_entry_length (entry,
RTEMS_RFS_DIR_ENTRY_SIZE + length);
memcpy (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length);
rtems_rfs_buffer_mark_dirty (&buffer);
3a5b8: e5cd307c strb r3, [sp, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
3a5bc: ebfffdb0 bl 39c84 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
3a5c0: e1a00004 mov r0, r4 <== NOT EXECUTED 3a5c4: e1a01006 mov r1, r6 <== NOT EXECUTED 3a5c8: ebfffb99 bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED 3a5cc: e3a09000 mov r9, #0 <== NOT EXECUTED
return 0;
3a5d0: eaffff36 b 3a2b0 <rtems_rfs_dir_add_entry+0x28> <== NOT EXECUTED
00039f84 <rtems_rfs_dir_del_entry>:
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
39f84: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
39f88: e24dd07c sub sp, sp, #124 ; 0x7c <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
39f8c: e28d601c add r6, sp, #28 <== NOT EXECUTED
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
39f90: e1a05002 mov r5, r2 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
39f94: e1a02006 mov r2, r6 <== NOT EXECUTED
int
rtems_rfs_dir_del_entry (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_ino ino,
uint32_t offset)
{
39f98: e58d3010 str r3, [sp, #16] <== NOT EXECUTED 39f9c: e1a04000 mov r4, r0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_DEL_ENTRY))
printf ("rtems-rfs: dir-del-entry: dir=%" PRId32 ", entry=%" PRId32 " offset=%" PRIu32 "\n",
rtems_rfs_inode_ino (dir), ino, offset);
rc = rtems_rfs_block_map_open (fs, dir, &map);
39fa0: ebfffd96 bl 39600 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
39fa4: e250b000 subs fp, r0, #0 <== NOT EXECUTED 39fa8: da000002 ble 39fb8 <rtems_rfs_dir_del_entry+0x34> <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
39fac: e1a0000b mov r0, fp <== NOT EXECUTED
39fb0: e28dd07c add sp, sp, #124 ; 0x7c <== NOT EXECUTED
39fb4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
39fb8: e3a07000 mov r7, #0 <== NOT EXECUTED 39fbc: e28dc078 add ip, sp, #120 ; 0x78 <== NOT EXECUTED 39fc0: e1a00004 mov r0, r4 <== NOT EXECUTED 39fc4: e1a01006 mov r1, r6 <== NOT EXECUTED 39fc8: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 39fcc: e1a03007 mov r3, r7 <== NOT EXECUTED 39fd0: e58dc000 str ip, [sp] <== NOT EXECUTED 39fd4: ebfffacf bl 38b18 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
39fd8: e250b000 subs fp, r0, #0 <== NOT EXECUTED 39fdc: da000005 ble 39ff8 <rtems_rfs_dir_del_entry+0x74> <== NOT EXECUTED
{
if (rc == ENXIO)
39fe0: e35b0006 cmp fp, #6 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
39fe4: e1a00004 mov r0, r4 <== NOT EXECUTED 39fe8: e1a01006 mov r1, r6 <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
if (rc > 0)
{
if (rc == ENXIO)
39fec: 03a0b002 moveq fp, #2 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
39ff0: ebfffd0f bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
39ff4: eaffffec b 39fac <rtems_rfs_dir_del_entry+0x28> <== NOT EXECUTED
}
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
39ff8: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 39ffc: e2722001 rsbs r2, r2, #1 <== NOT EXECUTED 3a000: 33a02000 movcc r2, #0 <== NOT EXECUTED
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a004: e3a09801 mov r9, #65536 ; 0x10000 <== NOT EXECUTED
handle->buffer = NULL;
3a008: e58d7074 str r7, [sp, #116] ; 0x74 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
3a00c: e5cd706c strb r7, [sp, #108] ; 0x6c <== NOT EXECUTED
handle->bnum = 0;
3a010: e58d7070 str r7, [sp, #112] ; 0x70 <== NOT EXECUTED
}
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
3a014: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 3a018: e58d500c str r5, [sp, #12] <== NOT EXECUTED
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a01c: e2499001 sub r9, r9, #1 <== NOT EXECUTED
while (rc == 0)
{
uint8_t* entry;
int eoffset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
3a020: e1a00004 mov r0, r4 <== NOT EXECUTED 3a024: e28d106c add r1, sp, #108 ; 0x6c <== NOT EXECUTED 3a028: e59d2078 ldr r2, [sp, #120] ; 0x78 <== NOT EXECUTED 3a02c: e3a03001 mov r3, #1 <== NOT EXECUTED 3a030: ebfffe87 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
3a034: e3500000 cmp r0, #0 <== NOT EXECUTED 3a038: e58d0018 str r0, [sp, #24] <== NOT EXECUTED 3a03c: ca00004b bgt 3a170 <rtems_rfs_dir_del_entry+0x1ec> <== NOT EXECUTED
/*
* If we are searching start at the beginning of the block. If not searching
* skip to the offset in the block.
*/
if (search)
3a040: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3a044: e3530000 cmp r3, #0 <== NOT EXECUTED 3a048: 0a00003e beq 3a148 <rtems_rfs_dir_del_entry+0x1c4> <== NOT EXECUTED 3a04c: e594c008 ldr ip, [r4, #8] <== NOT EXECUTED 3a050: e3a03000 mov r3, #0 <== NOT EXECUTED 3a054: e58dc014 str ip, [sp, #20] <== NOT EXECUTED 3a058: e1a00003 mov r0, r3 <== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a05c: e59dc014 ldr ip, [sp, #20] <== NOT EXECUTED
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
3a060: e59d2074 ldr r2, [sp, #116] ; 0x74 <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a064: e24ce00a sub lr, ip, #10 <== NOT EXECUTED 3a068: e153000e cmp r3, lr <== NOT EXECUTED
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
3a06c: e5922020 ldr r2, [r2, #32] <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a070: 2a00003b bcs 3a164 <rtems_rfs_dir_del_entry+0x1e0> <== NOT EXECUTED
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
3a074: e0827003 add r7, r2, r3 <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
3a078: e5d71009 ldrb r1, [r7, #9] <== NOT EXECUTED 3a07c: e5d78008 ldrb r8, [r7, #8] <== NOT EXECUTED 3a080: e1818408 orr r8, r1, r8, lsl #8 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a084: e1580009 cmp r8, r9 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
3a088: e7d21003 ldrb r1, [r2, r3] <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
3a08c: e287b008 add fp, r7, #8 <== NOT EXECUTED 3a090: e287a009 add sl, r7, #9 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
3a094: e5d73001 ldrb r3, [r7, #1] <== NOT EXECUTED 3a098: e5d7c002 ldrb ip, [r7, #2] <== NOT EXECUTED 3a09c: e5d72003 ldrb r2, [r7, #3] <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a0a0: 0a00002f beq 3a164 <rtems_rfs_dir_del_entry+0x1e0> <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
3a0a4: e358000a cmp r8, #10 <== NOT EXECUTED 3a0a8: da000024 ble 3a140 <rtems_rfs_dir_del_entry+0x1bc> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
3a0ac: e1822c01 orr r2, r2, r1, lsl #24 <== NOT EXECUTED 3a0b0: e1823803 orr r3, r2, r3, lsl #16 <== NOT EXECUTED 3a0b4: e183340c orr r3, r3, ip, lsl #8 <== NOT EXECUTED 3a0b8: e5945018 ldr r5, [r4, #24] <== NOT EXECUTED 3a0bc: ea00001c b 3a134 <rtems_rfs_dir_del_entry+0x1b0> <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
3a0c0: e5942010 ldr r2, [r4, #16] <== NOT EXECUTED 3a0c4: e1520003 cmp r2, r3 <== NOT EXECUTED 3a0c8: 3a00001c bcc 3a140 <rtems_rfs_dir_del_entry+0x1bc> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, block, eoffset);
rc = EIO;
break;
}
if (ino == rtems_rfs_dir_entry_ino (entry))
3a0cc: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 3a0d0: e1530002 cmp r3, r2 <== NOT EXECUTED 3a0d4: 0a000039 beq 3a1c0 <rtems_rfs_dir_del_entry+0x23c> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
}
if (!search)
3a0d8: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 3a0dc: e3520000 cmp r2, #0 <== NOT EXECUTED
{
rc = EIO;
break;
}
entry += elength;
3a0e0: e0877008 add r7, r7, r8 <== NOT EXECUTED
eoffset += elength;
3a0e4: e0800008 add r0, r0, r8 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return 0;
}
if (!search)
3a0e8: 0a000014 beq 3a140 <rtems_rfs_dir_del_entry+0x1bc> <== NOT EXECUTED
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
entry = rtems_rfs_buffer_data (&buffer) + eoffset;
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a0ec: e150000e cmp r0, lr <== NOT EXECUTED 3a0f0: 2a00001b bcs 3a164 <rtems_rfs_dir_del_entry+0x1e0> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
3a0f4: e5d73009 ldrb r3, [r7, #9] <== NOT EXECUTED 3a0f8: e5d78008 ldrb r8, [r7, #8] <== NOT EXECUTED 3a0fc: e1838408 orr r8, r3, r8, lsl #8 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a100: e1580009 cmp r8, r9 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
3a104: e5d7c000 ldrb ip, [r7] <== NOT EXECUTED 3a108: e5d72001 ldrb r2, [r7, #1] <== NOT EXECUTED 3a10c: e5d73002 ldrb r3, [r7, #2] <== NOT EXECUTED 3a110: e5d71003 ldrb r1, [r7, #3] <== NOT EXECUTED
while (eoffset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
3a114: e287b008 add fp, r7, #8 <== NOT EXECUTED 3a118: e287a009 add sl, r7, #9 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a11c: 0a000010 beq 3a164 <rtems_rfs_dir_del_entry+0x1e0> <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
3a120: e358000a cmp r8, #10 <== NOT EXECUTED 3a124: da000005 ble 3a140 <rtems_rfs_dir_del_entry+0x1bc> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
3a128: e1811c0c orr r1, r1, ip, lsl #24 <== NOT EXECUTED 3a12c: e1811802 orr r1, r1, r2, lsl #16 <== NOT EXECUTED 3a130: e1813403 orr r3, r1, r3, lsl #8 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
3a134: e3530000 cmp r3, #0 <== NOT EXECUTED 3a138: 11580005 cmpne r8, r5 <== NOT EXECUTED 3a13c: 3affffdf bcc 3a0c0 <rtems_rfs_dir_del_entry+0x13c> <== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
3a140: e3a0b005 mov fp, #5 <== NOT EXECUTED 3a144: ea00000a b 3a174 <rtems_rfs_dir_del_entry+0x1f0> <== NOT EXECUTED
* skip to the offset in the block.
*/
if (search)
eoffset = 0;
else
eoffset = offset % rtems_rfs_fs_block_size (fs);
3a148: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 3a14c: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED 3a150: e1a01002 mov r1, r2 <== NOT EXECUTED 3a154: e58d2014 str r2, [sp, #20] <== NOT EXECUTED 3a158: eb0083f6 bl 5b138 <__umodsi3> <== NOT EXECUTED 3a15c: e1a03000 mov r3, r0 <== NOT EXECUTED 3a160: eaffffbd b 3a05c <rtems_rfs_dir_del_entry+0xd8> <== NOT EXECUTED
entry += elength;
eoffset += elength;
}
if (rc == 0)
3a164: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 3a168: e3530000 cmp r3, #0 <== NOT EXECUTED 3a16c: 0a000007 beq 3a190 <rtems_rfs_dir_del_entry+0x20c> <== NOT EXECUTED 3a170: e59db018 ldr fp, [sp, #24] <== NOT EXECUTED
if (rc == ENXIO)
rc = ENOENT;
}
}
rtems_rfs_buffer_handle_close (fs, &buffer);
3a174: e28d106c add r1, sp, #108 ; 0x6c <== NOT EXECUTED 3a178: e1a00004 mov r0, r4 <== NOT EXECUTED 3a17c: ebfffec0 bl 39c84 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
3a180: e1a00004 mov r0, r4 <== NOT EXECUTED 3a184: e1a01006 mov r1, r6 <== NOT EXECUTED 3a188: ebfffca9 bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
3a18c: eaffff86 b 39fac <rtems_rfs_dir_del_entry+0x28> <== NOT EXECUTED
eoffset += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
3a190: e1a00004 mov r0, r4 <== NOT EXECUTED 3a194: e1a01006 mov r1, r6 <== NOT EXECUTED 3a198: e28d2078 add r2, sp, #120 ; 0x78 <== NOT EXECUTED 3a19c: ebfffa50 bl 38ae4 <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc == ENXIO)
3a1a0: e3500006 cmp r0, #6 <== NOT EXECUTED
eoffset += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
3a1a4: e58d0018 str r0, [sp, #24] <== NOT EXECUTED
if (rc == ENXIO)
3a1a8: 0a000034 beq 3a280 <rtems_rfs_dir_del_entry+0x2fc> <== NOT EXECUTED
/*
* Only search if the offset is 0 else we are at that position.
*/
search = offset ? false : true;
while (rc == 0)
3a1ac: e59dc018 ldr ip, [sp, #24] <== NOT EXECUTED 3a1b0: e35c0000 cmp ip, #0 <== NOT EXECUTED 3a1b4: 0affff99 beq 3a020 <rtems_rfs_dir_del_entry+0x9c> <== NOT EXECUTED 3a1b8: e1a0b00c mov fp, ip <== NOT EXECUTED 3a1bc: eaffffec b 3a174 <rtems_rfs_dir_del_entry+0x1f0> <== NOT EXECUTED
}
if (ino == rtems_rfs_dir_entry_ino (entry))
{
uint32_t remaining;
remaining = rtems_rfs_fs_block_size (fs) - (eoffset + elength);
3a1c0: e59dc014 ldr ip, [sp, #20] <== NOT EXECUTED 3a1c4: e0805008 add r5, r0, r8 <== NOT EXECUTED 3a1c8: e065500c rsb r5, r5, ip <== NOT EXECUTED 3a1cc: e1a0900a mov r9, sl <== NOT EXECUTED
memmove (entry, entry + elength, remaining);
3a1d0: e0871008 add r1, r7, r8 <== NOT EXECUTED 3a1d4: e1a0a000 mov sl, r0 <== NOT EXECUTED 3a1d8: e1a02005 mov r2, r5 <== NOT EXECUTED 3a1dc: e1a00007 mov r0, r7 <== NOT EXECUTED 3a1e0: e58db004 str fp, [sp, #4] <== NOT EXECUTED 3a1e4: eb00306d bl 463a0 <memmove> <== NOT EXECUTED
memset (entry + remaining, 0xff, elength);
3a1e8: e1a02008 mov r2, r8 <== NOT EXECUTED 3a1ec: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED 3a1f0: e0870005 add r0, r7, r5 <== NOT EXECUTED 3a1f4: eb0030b4 bl 464cc <memset> <== NOT EXECUTED
* block and it is the last block in the map shrink the map.
*
* @note We could check again to see if the new end block in the map is
* also empty. This way we could clean up an empty directory.
*/
elength = rtems_rfs_dir_entry_length (entry);
3a1f8: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 3a1fc: e5d92000 ldrb r2, [r9] <== NOT EXECUTED 3a200: e5d31000 ldrb r1, [r3] <== NOT EXECUTED 3a204: e3a03801 mov r3, #65536 ; 0x10000 <== NOT EXECUTED 3a208: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED 3a20c: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3a210: e1520003 cmp r2, r3 <== NOT EXECUTED 3a214: 035a0000 cmpeq sl, #0 <== NOT EXECUTED 3a218: 1a00000a bne 3a248 <rtems_rfs_dir_del_entry+0x2c4> <== NOT EXECUTED
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
(eoffset == 0) && rtems_rfs_block_map_last (&map))
3a21c: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
3a220: e3530000 cmp r3, #0 <== NOT EXECUTED 3a224: 159d2024 ldrne r2, [sp, #36] ; 0x24 <== NOT EXECUTED 3a228: 1a000010 bne 3a270 <rtems_rfs_dir_del_entry+0x2ec> <== NOT EXECUTED
(eoffset == 0) && rtems_rfs_block_map_last (&map))
3a22c: e59d2024 ldr r2, [sp, #36] ; 0x24 <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
3a230: e3520000 cmp r2, #0 <== NOT EXECUTED 3a234: 1a00000d bne 3a270 <rtems_rfs_dir_del_entry+0x2ec> <== NOT EXECUTED
(eoffset == 0) && rtems_rfs_block_map_last (&map))
{
rc = rtems_rfs_block_map_shrink (fs, &map, 1);
3a238: e1a00004 mov r0, r4 <== NOT EXECUTED 3a23c: e1a01006 mov r1, r6 <== NOT EXECUTED 3a240: e3a02001 mov r2, #1 <== NOT EXECUTED 3a244: ebfffa7b bl 38c38 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
"block map shrink failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
3a248: e3a03001 mov r3, #1 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
3a24c: e28d106c add r1, sp, #108 ; 0x6c <== NOT EXECUTED 3a250: e1a00004 mov r0, r4 <== NOT EXECUTED
"block map shrink failed for ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (dir), rc, strerror (rc));
}
}
rtems_rfs_buffer_mark_dirty (&buffer);
3a254: e5cd306c strb r3, [sp, #108] ; 0x6c <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
3a258: ebfffe89 bl 39c84 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
3a25c: e1a00004 mov r0, r4 <== NOT EXECUTED 3a260: e1a01006 mov r1, r6 <== NOT EXECUTED 3a264: ebfffc72 bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED 3a268: e3a0b000 mov fp, #0 <== NOT EXECUTED
return 0;
3a26c: eaffff4e b 39fac <rtems_rfs_dir_del_entry+0x28> <== NOT EXECUTED
"last block free for ino %" PRIu32 ": elength=%i block=%" PRIu32
" offset=%d last=%s\n",
ino, elength, block, eoffset,
rtems_rfs_block_map_last (&map) ? "yes" : "no");
if ((elength == RTEMS_RFS_DIR_ENTRY_EMPTY) &&
3a270: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3a274: e1530002 cmp r3, r2 <== NOT EXECUTED 3a278: 1afffff2 bne 3a248 <rtems_rfs_dir_del_entry+0x2c4> <== NOT EXECUTED 3a27c: eaffffed b 3a238 <rtems_rfs_dir_del_entry+0x2b4> <== NOT EXECUTED
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
if (rc == ENXIO)
3a280: e3a0b002 mov fp, #2 <== NOT EXECUTED 3a284: eaffffba b 3a174 <rtems_rfs_dir_del_entry+0x1f0> <== NOT EXECUTED
0003a838 <rtems_rfs_dir_empty>:
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
3a838: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3a83c: e24dd064 sub sp, sp, #100 ; 0x64 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
3a840: e28d6004 add r6, sp, #4 <== NOT EXECUTED 3a844: e1a02006 mov r2, r6 <== NOT EXECUTED
}
int
rtems_rfs_dir_empty (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir)
{
3a848: e1a04000 mov r4, r0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-empty: dir=%" PRId32 "\n", rtems_rfs_inode_ino (dir));
empty = true;
rc = rtems_rfs_block_map_open (fs, dir, &map);
3a84c: ebfffb6b bl 39600 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
3a850: e2508000 subs r8, r0, #0 <== NOT EXECUTED 3a854: da000002 ble 3a864 <rtems_rfs_dir_empty+0x2c> <== NOT EXECUTED
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
3a858: e1a00008 mov r0, r8 <== NOT EXECUTED
3a85c: e28dd064 add sp, sp, #100 ; 0x64 <== NOT EXECUTED
3a860: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
3a864: e28dc060 add ip, sp, #96 ; 0x60 <== NOT EXECUTED 3a868: e1a00004 mov r0, r4 <== NOT EXECUTED 3a86c: e1a01006 mov r1, r6 <== NOT EXECUTED 3a870: e3a02000 mov r2, #0 <== NOT EXECUTED 3a874: e3a03000 mov r3, #0 <== NOT EXECUTED 3a878: e58dc000 str ip, [sp] <== NOT EXECUTED 3a87c: ebfff8a5 bl 38b18 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
3a880: e2508000 subs r8, r0, #0 <== NOT EXECUTED 3a884: ca00005e bgt 3aa04 <rtems_rfs_dir_empty+0x1cc> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
3a888: e3a03000 mov r3, #0 <== NOT EXECUTED
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a88c: e3a05801 mov r5, #65536 ; 0x10000 <== NOT EXECUTED
handle->bnum = 0; handle->buffer = NULL;
3a890: e58d305c str r3, [sp, #92] ; 0x5c <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
3a894: e5cd3054 strb r3, [sp, #84] ; 0x54 <== NOT EXECUTED
handle->bnum = 0;
3a898: e58d3058 str r3, [sp, #88] ; 0x58 <== NOT EXECUTED 3a89c: e2455001 sub r5, r5, #1 <== NOT EXECUTED 3a8a0: e28d7054 add r7, sp, #84 ; 0x54 <== NOT EXECUTED
while (empty)
{
uint8_t* entry;
int offset;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
3a8a4: e1a00004 mov r0, r4 <== NOT EXECUTED 3a8a8: e1a01007 mov r1, r7 <== NOT EXECUTED 3a8ac: e59d2060 ldr r2, [sp, #96] ; 0x60 <== NOT EXECUTED 3a8b0: e3a03001 mov r3, #1 <== NOT EXECUTED 3a8b4: ebfffc66 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
3a8b8: e2508000 subs r8, r0, #0 <== NOT EXECUTED 3a8bc: ca00003c bgt 3a9b4 <rtems_rfs_dir_empty+0x17c> <== NOT EXECUTED
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a8c0: e5949008 ldr r9, [r4, #8] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
3a8c4: e59d305c ldr r3, [sp, #92] ; 0x5c <== NOT EXECUTED
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a8c8: e259900a subs r9, r9, #10 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
break;
entry = rtems_rfs_buffer_data (&buffer);
3a8cc: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a8d0: 0a000042 beq 3a9e0 <rtems_rfs_dir_empty+0x1a8> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
3a8d4: e5d31008 ldrb r1, [r3, #8] <== NOT EXECUTED 3a8d8: e5d32009 ldrb r2, [r3, #9] <== NOT EXECUTED 3a8dc: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a8e0: e1520005 cmp r2, r5 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
3a8e4: e5d3e000 ldrb lr, [r3] <== NOT EXECUTED 3a8e8: e5d3c001 ldrb ip, [r3, #1] <== NOT EXECUTED 3a8ec: e5d30002 ldrb r0, [r3, #2] <== NOT EXECUTED 3a8f0: e5d31003 ldrb r1, [r3, #3] <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a8f4: 0a000039 beq 3a9e0 <rtems_rfs_dir_empty+0x1a8> <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
3a8f8: e352000a cmp r2, #10 <== NOT EXECUTED 3a8fc: da000037 ble 3a9e0 <rtems_rfs_dir_empty+0x1a8> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
3a900: e1811c0e orr r1, r1, lr, lsl #24 <== NOT EXECUTED 3a904: e181180c orr r1, r1, ip, lsl #16 <== NOT EXECUTED 3a908: e1811400 orr r1, r1, r0, lsl #8 <== NOT EXECUTED 3a90c: e594a018 ldr sl, [r4, #24] <== NOT EXECUTED 3a910: e3a0c000 mov ip, #0 <== NOT EXECUTED 3a914: ea000019 b 3a980 <rtems_rfs_dir_empty+0x148> <== NOT EXECUTED
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
3a918: e352000c cmp r2, #12 <== NOT EXECUTED 3a91c: 1a000022 bne 3a9ac <rtems_rfs_dir_empty+0x174> <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 2)) ||
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.') ||
3a920: e5d3100a ldrb r1, [r3, #10] <== NOT EXECUTED 3a924: e351002e cmp r1, #46 ; 0x2e <== NOT EXECUTED 3a928: 1a00001f bne 3a9ac <rtems_rfs_dir_empty+0x174> <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE + 1] != '.')))
3a92c: e5d3100b ldrb r1, [r3, #11] <== NOT EXECUTED 3a930: e351002e cmp r1, #46 ; 0x2e <== NOT EXECUTED 3a934: 1a00001c bne 3a9ac <rtems_rfs_dir_empty+0x174> <== NOT EXECUTED
empty = false;
break;
}
entry += elength;
offset += elength;
3a938: e08cc002 add ip, ip, r2 <== NOT EXECUTED
break;
entry = rtems_rfs_buffer_data (&buffer);
offset = 0;
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a93c: e15c0009 cmp ip, r9 <== NOT EXECUTED 3a940: 2a000026 bcs 3a9e0 <rtems_rfs_dir_empty+0x1a8> <== NOT EXECUTED
{
empty = false;
break;
}
entry += elength;
3a944: e0833002 add r3, r3, r2 <== NOT EXECUTED
while (offset < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
3a948: e5d31008 ldrb r1, [r3, #8] <== NOT EXECUTED 3a94c: e5d32009 ldrb r2, [r3, #9] <== NOT EXECUTED 3a950: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a954: e1520005 cmp r2, r5 <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
3a958: e5d3b000 ldrb fp, [r3] <== NOT EXECUTED 3a95c: e5d3e001 ldrb lr, [r3, #1] <== NOT EXECUTED 3a960: e5d30002 ldrb r0, [r3, #2] <== NOT EXECUTED 3a964: e5d31003 ldrb r1, [r3, #3] <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a968: 0a00001c beq 3a9e0 <rtems_rfs_dir_empty+0x1a8> <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
3a96c: e352000a cmp r2, #10 <== NOT EXECUTED 3a970: da00001a ble 3a9e0 <rtems_rfs_dir_empty+0x1a8> <== NOT EXECUTED
{
rtems_rfs_ino eino;
int elength;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
3a974: e1811c0b orr r1, r1, fp, lsl #24 <== NOT EXECUTED 3a978: e181180e orr r1, r1, lr, lsl #16 <== NOT EXECUTED 3a97c: e1811400 orr r1, r1, r0, lsl #8 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
3a980: e3510000 cmp r1, #0 <== NOT EXECUTED 3a984: 1152000a cmpne r2, sl <== NOT EXECUTED 3a988: 2a000014 bcs 3a9e0 <rtems_rfs_dir_empty+0x1a8> <== NOT EXECUTED 3a98c: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED 3a990: e1500001 cmp r0, r1 <== NOT EXECUTED 3a994: 3a000011 bcc 3a9e0 <rtems_rfs_dir_empty+0x1a8> <== NOT EXECUTED
/*
* Ignore the current (.) and parent (..) entries. Anything else means
* the directory is not empty.
*/
if (((elength != (RTEMS_RFS_DIR_ENTRY_SIZE + 1)) ||
3a998: e352000b cmp r2, #11 <== NOT EXECUTED 3a99c: 1affffdd bne 3a918 <rtems_rfs_dir_empty+0xe0> <== NOT EXECUTED
(entry[RTEMS_RFS_DIR_ENTRY_SIZE] != '.')) &&
3a9a0: e5d3100a ldrb r1, [r3, #10] <== NOT EXECUTED 3a9a4: e351002e cmp r1, #46 ; 0x2e <== NOT EXECUTED 3a9a8: 0affffe2 beq 3a938 <rtems_rfs_dir_empty+0x100> <== NOT EXECUTED
break;
}
}
}
if ((rc == 0) && !empty)
3a9ac: e3580000 cmp r8, #0 <== NOT EXECUTED 3a9b0: 03a0805a moveq r8, #90 ; 0x5a <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3a9b4: e1a01007 mov r1, r7 <== NOT EXECUTED 3a9b8: e1a00004 mov r0, r4 <== NOT EXECUTED 3a9bc: ebfffbda bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
3a9c0: e3a03000 mov r3, #0 <== NOT EXECUTED
rc = ENOTEMPTY;
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
3a9c4: e1a00004 mov r0, r4 <== NOT EXECUTED 3a9c8: e1a01006 mov r1, r6 <== NOT EXECUTED
handle->bnum = 0; handle->buffer = NULL;
3a9cc: e58d305c str r3, [sp, #92] ; 0x5c <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3a9d0: e5cd3054 strb r3, [sp, #84] ; 0x54 <== NOT EXECUTED
handle->bnum = 0;
3a9d4: e58d3058 str r3, [sp, #88] ; 0x58 <== NOT EXECUTED 3a9d8: ebfffa95 bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
3a9dc: eaffff9d b 3a858 <rtems_rfs_dir_empty+0x20> <== NOT EXECUTED
offset += elength;
}
if (empty)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
3a9e0: e1a00004 mov r0, r4 <== NOT EXECUTED 3a9e4: e1a01006 mov r1, r6 <== NOT EXECUTED 3a9e8: e28d2060 add r2, sp, #96 ; 0x60 <== NOT EXECUTED 3a9ec: ebfff83c bl 38ae4 <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc > 0)
3a9f0: e2508000 subs r8, r0, #0 <== NOT EXECUTED 3a9f4: daffffaa ble 3a8a4 <rtems_rfs_dir_empty+0x6c> <== NOT EXECUTED
{
if (rc == ENXIO)
3a9f8: e3580006 cmp r8, #6 <== NOT EXECUTED 3a9fc: 03a08000 moveq r8, #0 <== NOT EXECUTED 3aa00: eaffffeb b 3a9b4 <rtems_rfs_dir_empty+0x17c> <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
3aa04: e1a00004 mov r0, r4 <== NOT EXECUTED 3aa08: e1a01006 mov r1, r6 <== NOT EXECUTED 3aa0c: ebfffa88 bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
3aa10: eaffff90 b 3a858 <rtems_rfs_dir_empty+0x20> <== NOT EXECUTED
00042a98 <rtems_rfs_dir_hash>:
{
uint32_t a,b,c; /* internal state */
union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
/* Set up the internal state */
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
42a98: e281320e add r3, r1, #-536870912 ; 0xe0000000 <== NOT EXECUTED 42a9c: e2433983 sub r3, r3, #2146304 ; 0x20c000 <== NOT EXECUTED 42aa0: e2433da5 sub r3, r3, #10560 ; 0x2940 <== NOT EXECUTED
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
42aa4: e351000c cmp r1, #12 <== NOT EXECUTED
{
uint32_t a,b,c; /* internal state */
union { const void *ptr; size_t i; } u; /* needed for Mac Powerbook G4 */
/* Set up the internal state */
a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
42aa8: e2433021 sub r3, r3, #33 ; 0x21 <== NOT EXECUTED
*/
#define initval (20010928)
uint32_t
rtems_rfs_dir_hash (const void *key, size_t length)
{
42aac: e92d0ff0 push {r4, r5, r6, r7, r8, r9, sl, fp} <== NOT EXECUTED
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
42ab0: 91a0c003 movls ip, r3 <== NOT EXECUTED 42ab4: 91a02003 movls r2, r3 <== NOT EXECUTED 42ab8: 9a000032 bls 42b88 <rtems_rfs_dir_hash+0xf0> <== NOT EXECUTED 42abc: e1a0c003 mov ip, r3 <== NOT EXECUTED 42ac0: e1a02003 mov r2, r3 <== NOT EXECUTED
{
a += k[0];
42ac4: e5d09002 ldrb r9, [r0, #2] <== NOT EXECUTED
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
42ac8: e5d0800a ldrb r8, [r0, #10] <== NOT EXECUTED
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
42acc: e5d05001 ldrb r5, [r0, #1] <== NOT EXECUTED
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
42ad0: e5d04009 ldrb r4, [r0, #9] <== NOT EXECUTED
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
42ad4: e5d0a000 ldrb sl, [r0] <== NOT EXECUTED
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
42ad8: e5d06006 ldrb r6, [r0, #6] <== NOT EXECUTED
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
42adc: e5d07008 ldrb r7, [r0, #8] <== NOT EXECUTED
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
42ae0: e1a09809 lsl r9, r9, #16 <== NOT EXECUTED
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
42ae4: e1a08808 lsl r8, r8, #16 <== NOT EXECUTED
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
42ae8: e0899405 add r9, r9, r5, lsl #8 <== NOT EXECUTED
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
42aec: e0888404 add r8, r8, r4, lsl #8 <== NOT EXECUTED
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
42af0: e5d05003 ldrb r5, [r0, #3] <== NOT EXECUTED
a += ((uint32_t)k[3])<<24;
b += k[4];
42af4: e5d04005 ldrb r4, [r0, #5] <== NOT EXECUTED
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
42af8: e5d0b00b ldrb fp, [r0, #11] <== NOT EXECUTED
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
42afc: e089a00a add sl, r9, sl <== NOT EXECUTED
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
42b00: e1a06806 lsl r6, r6, #16 <== NOT EXECUTED
b += ((uint32_t)k[5])<<8;
42b04: e5d09004 ldrb r9, [r0, #4] <== NOT EXECUTED
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
42b08: e0887007 add r7, r8, r7 <== NOT EXECUTED
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
42b0c: e08aac05 add sl, sl, r5, lsl #24 <== NOT EXECUTED
a += ((uint32_t)k[3])<<24;
b += k[4];
42b10: e0864404 add r4, r6, r4, lsl #8 <== NOT EXECUTED
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
42b14: e5d05007 ldrb r5, [r0, #7] <== NOT EXECUTED
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
42b18: e0877c0b add r7, r7, fp, lsl #24 <== NOT EXECUTED
c += ((uint32_t)k[11])<<24;
42b1c: e0873003 add r3, r7, r3 <== NOT EXECUTED
while (length > 12)
{
a += k[0];
a += ((uint32_t)k[1])<<8;
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
42b20: e08a2002 add r2, sl, r2 <== NOT EXECUTED
b += k[4];
b += ((uint32_t)k[5])<<8;
42b24: e0844009 add r4, r4, r9 <== NOT EXECUTED
b += ((uint32_t)k[6])<<16;
42b28: e0844c05 add r4, r4, r5, lsl #24 <== NOT EXECUTED
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
42b2c: e0632002 rsb r2, r3, r2 <== NOT EXECUTED 42b30: e0222e63 eor r2, r2, r3, ror #28 <== NOT EXECUTED
a += ((uint32_t)k[2])<<16;
a += ((uint32_t)k[3])<<24;
b += k[4];
b += ((uint32_t)k[5])<<8;
b += ((uint32_t)k[6])<<16;
b += ((uint32_t)k[7])<<24;
42b34: e084c00c add ip, r4, ip <== NOT EXECUTED
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
42b38: e062600c rsb r6, r2, ip <== NOT EXECUTED 42b3c: e0266d62 eor r6, r6, r2, ror #26 <== NOT EXECUTED 42b40: e083300c add r3, r3, ip <== NOT EXECUTED 42b44: e0664003 rsb r4, r6, r3 <== NOT EXECUTED 42b48: e0244c66 eor r4, r4, r6, ror #24 <== NOT EXECUTED 42b4c: e0823003 add r3, r2, r3 <== NOT EXECUTED 42b50: e0642003 rsb r2, r4, r3 <== NOT EXECUTED 42b54: e0222864 eor r2, r2, r4, ror #16 <== NOT EXECUTED 42b58: e0866003 add r6, r6, r3 <== NOT EXECUTED 42b5c: e062c006 rsb ip, r2, r6 <== NOT EXECUTED 42b60: e02cc6e2 eor ip, ip, r2, ror #13 <== NOT EXECUTED 42b64: e0844006 add r4, r4, r6 <== NOT EXECUTED
length -= 12;
42b68: e241100c sub r1, r1, #12 <== NOT EXECUTED
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
42b6c: e0822004 add r2, r2, r4 <== NOT EXECUTED
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
42b70: e351000c cmp r1, #12 <== NOT EXECUTED
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
42b74: e06c4004 rsb r4, ip, r4 <== NOT EXECUTED 42b78: e0243e6c eor r3, r4, ip, ror #28 <== NOT EXECUTED
length -= 12;
k += 12;
42b7c: e280000c add r0, r0, #12 <== NOT EXECUTED
b += ((uint32_t)k[7])<<24;
c += k[8];
c += ((uint32_t)k[9])<<8;
c += ((uint32_t)k[10])<<16;
c += ((uint32_t)k[11])<<24;
mix(a,b,c);
42b80: e08cc002 add ip, ip, r2 <== NOT EXECUTED
} else { /* need to read the key one byte at a time */
const uint8_t *k = (const uint8_t *)key;
/*--------------- all but the last block: affect some 32 bits of (a,b,c) */
while (length > 12)
42b84: 8affffce bhi 42ac4 <rtems_rfs_dir_hash+0x2c> <== NOT EXECUTED
length -= 12;
k += 12;
}
/*-------------------------------- last block: affect all 32 bits of (c) */
switch(length) /* all the case statements fall through */
42b88: e2411001 sub r1, r1, #1 <== NOT EXECUTED 42b8c: e351000b cmp r1, #11 <== NOT EXECUTED 42b90: 979ff101 ldrls pc, [pc, r1, lsl #2] <== NOT EXECUTED 42b94: ea000031 b 42c60 <rtems_rfs_dir_hash+0x1c8> <== NOT EXECUTED 42b98: 00042c20 .word 0x00042c20 <== NOT EXECUTED 42b9c: 00042c18 .word 0x00042c18 <== NOT EXECUTED 42ba0: 00042c10 .word 0x00042c10 <== NOT EXECUTED 42ba4: 00042c08 .word 0x00042c08 <== NOT EXECUTED 42ba8: 00042c00 .word 0x00042c00 <== NOT EXECUTED 42bac: 00042bf8 .word 0x00042bf8 <== NOT EXECUTED 42bb0: 00042bf0 .word 0x00042bf0 <== NOT EXECUTED 42bb4: 00042be8 .word 0x00042be8 <== NOT EXECUTED 42bb8: 00042be0 .word 0x00042be0 <== NOT EXECUTED 42bbc: 00042bd8 .word 0x00042bd8 <== NOT EXECUTED 42bc0: 00042bd0 .word 0x00042bd0 <== NOT EXECUTED 42bc4: 00042bc8 .word 0x00042bc8 <== NOT EXECUTED
{
case 12: c+=((uint32_t)k[11])<<24;
42bc8: e5d0100b ldrb r1, [r0, #11] <== NOT EXECUTED 42bcc: e0833c01 add r3, r3, r1, lsl #24 <== NOT EXECUTED
case 11: c+=((uint32_t)k[10])<<16;
42bd0: e5d0100a ldrb r1, [r0, #10] <== NOT EXECUTED 42bd4: e0833801 add r3, r3, r1, lsl #16 <== NOT EXECUTED
case 10: c+=((uint32_t)k[9])<<8;
42bd8: e5d01009 ldrb r1, [r0, #9] <== NOT EXECUTED 42bdc: e0833401 add r3, r3, r1, lsl #8 <== NOT EXECUTED
case 9 : c+=k[8];
42be0: e5d01008 ldrb r1, [r0, #8] <== NOT EXECUTED 42be4: e0833001 add r3, r3, r1 <== NOT EXECUTED
case 8 : b+=((uint32_t)k[7])<<24;
42be8: e5d01007 ldrb r1, [r0, #7] <== NOT EXECUTED 42bec: e08ccc01 add ip, ip, r1, lsl #24 <== NOT EXECUTED
case 7 : b+=((uint32_t)k[6])<<16;
42bf0: e5d01006 ldrb r1, [r0, #6] <== NOT EXECUTED 42bf4: e08cc801 add ip, ip, r1, lsl #16 <== NOT EXECUTED
case 6 : b+=((uint32_t)k[5])<<8;
42bf8: e5d01005 ldrb r1, [r0, #5] <== NOT EXECUTED 42bfc: e08cc401 add ip, ip, r1, lsl #8 <== NOT EXECUTED
case 5 : b+=k[4];
42c00: e5d01004 ldrb r1, [r0, #4] <== NOT EXECUTED 42c04: e08cc001 add ip, ip, r1 <== NOT EXECUTED
case 4 : a+=((uint32_t)k[3])<<24;
42c08: e5d01003 ldrb r1, [r0, #3] <== NOT EXECUTED 42c0c: e0822c01 add r2, r2, r1, lsl #24 <== NOT EXECUTED
case 3 : a+=((uint32_t)k[2])<<16;
42c10: e5d01002 ldrb r1, [r0, #2] <== NOT EXECUTED 42c14: e0822801 add r2, r2, r1, lsl #16 <== NOT EXECUTED
case 2 : a+=((uint32_t)k[1])<<8;
42c18: e5d01001 ldrb r1, [r0, #1] <== NOT EXECUTED 42c1c: e0822401 add r2, r2, r1, lsl #8 <== NOT EXECUTED
case 1 : a+=k[0];
42c20: e5d01000 ldrb r1, [r0] <== NOT EXECUTED
break;
case 0 : return c;
}
}
final(a,b,c);
42c24: e023300c eor r3, r3, ip <== NOT EXECUTED 42c28: e043396c sub r3, r3, ip, ror #18 <== NOT EXECUTED
case 6 : b+=((uint32_t)k[5])<<8;
case 5 : b+=k[4];
case 4 : a+=((uint32_t)k[3])<<24;
case 3 : a+=((uint32_t)k[2])<<16;
case 2 : a+=((uint32_t)k[1])<<8;
case 1 : a+=k[0];
42c2c: e0822001 add r2, r2, r1 <== NOT EXECUTED
break;
case 0 : return c;
}
}
final(a,b,c);
42c30: e0232002 eor r2, r3, r2 <== NOT EXECUTED 42c34: e0422ae3 sub r2, r2, r3, ror #21 <== NOT EXECUTED 42c38: e022c00c eor ip, r2, ip <== NOT EXECUTED 42c3c: e04cc3e2 sub ip, ip, r2, ror #7 <== NOT EXECUTED 42c40: e02c3003 eor r3, ip, r3 <== NOT EXECUTED 42c44: e043186c sub r1, r3, ip, ror #16 <== NOT EXECUTED 42c48: e0212002 eor r2, r1, r2 <== NOT EXECUTED 42c4c: e0422e61 sub r2, r2, r1, ror #28 <== NOT EXECUTED 42c50: e022c00c eor ip, r2, ip <== NOT EXECUTED 42c54: e04cc962 sub ip, ip, r2, ror #18 <== NOT EXECUTED 42c58: e02c3001 eor r3, ip, r1 <== NOT EXECUTED 42c5c: e043346c sub r3, r3, ip, ror #8 <== NOT EXECUTED
return c; }
42c60: e1a00003 mov r0, r3 <== NOT EXECUTED
42c64: e8bd0ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp} <== NOT EXECUTED
42c68: e12fff1e bx lr <== NOT EXECUTED
0003a5d4 <rtems_rfs_dir_lookup_ino>:
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
3a5d4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3a5d8: e24dd070 sub sp, sp, #112 ; 0x70 <== NOT EXECUTED
3a5dc: e59d5094 ldr r5, [sp, #148] ; 0x94 <== NOT EXECUTED
3a5e0: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
3a5e4: e59d2098 ldr r2, [sp, #152] ; 0x98 <== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
3a5e8: e3a06000 mov r6, #0 <== NOT EXECUTED
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
3a5ec: e28db010 add fp, sp, #16 <== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf (", len=%d\n", length);
}
*ino = RTEMS_RFS_EMPTY_INO;
3a5f0: e5856000 str r6, [r5] <== NOT EXECUTED
*offset = 0;
3a5f4: e5826000 str r6, [r2] <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, inode, &map);
3a5f8: e1a0200b mov r2, fp <== NOT EXECUTED
rtems_rfs_inode_handle* inode,
const char* name,
int length,
rtems_rfs_ino* ino,
uint32_t* offset)
{
3a5fc: e1a08003 mov r8, r3 <== NOT EXECUTED 3a600: e1a04000 mov r4, r0 <== NOT EXECUTED
}
*ino = RTEMS_RFS_EMPTY_INO;
*offset = 0;
rc = rtems_rfs_block_map_open (fs, inode, &map);
3a604: ebfffbfd bl 39600 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
3a608: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3a60c: da000002 ble 3a61c <rtems_rfs_dir_lookup_ino+0x48> <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
3a610: e1a00009 mov r0, r9 <== NOT EXECUTED
3a614: e28dd070 add sp, sp, #112 ; 0x70 <== NOT EXECUTED
3a618: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
3a61c: e1a01008 mov r1, r8 <== NOT EXECUTED 3a620: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
3a624: e5cd6060 strb r6, [sp, #96] ; 0x60 <== NOT EXECUTED
handle->bnum = 0;
3a628: e58d6064 str r6, [sp, #100] ; 0x64 <== NOT EXECUTED
handle->buffer = NULL;
3a62c: e58d6068 str r6, [sp, #104] ; 0x68 <== NOT EXECUTED 3a630: eb002118 bl 42a98 <rtems_rfs_dir_hash> <== NOT EXECUTED
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
3a634: e28dc06c add ip, sp, #108 ; 0x6c <== NOT EXECUTED
uint32_t hash;
/*
* Calculate the hash of the look up string.
*/
hash = rtems_rfs_dir_hash (name, length);
3a638: e1a07000 mov r7, r0 <== NOT EXECUTED
/*
* Locate the first block. The map points to the start after open so just
* seek 0. If an error the block will be 0.
*/
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
3a63c: e1a0100b mov r1, fp <== NOT EXECUTED 3a640: e1a00004 mov r0, r4 <== NOT EXECUTED 3a644: e3a02000 mov r2, #0 <== NOT EXECUTED 3a648: e3a03000 mov r3, #0 <== NOT EXECUTED 3a64c: e58dc000 str ip, [sp] <== NOT EXECUTED 3a650: ebfff930 bl 38b18 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
3a654: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3a658: da00000b ble 3a68c <rtems_rfs_dir_lookup_ino+0xb8> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3a65c: e28d1060 add r1, sp, #96 ; 0x60 <== NOT EXECUTED 3a660: e1a00004 mov r0, r4 <== NOT EXECUTED 3a664: ebfffcb0 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
rc, strerror (rc));
if (rc == ENXIO)
3a668: e3590006 cmp r9, #6 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
3a66c: e1a00004 mov r0, r4 <== NOT EXECUTED 3a670: e1a0100b mov r1, fp <== NOT EXECUTED
if (rc > 0)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block map find failed: %d: %s\n",
rc, strerror (rc));
if (rc == ENXIO)
3a674: 03a09002 moveq r9, #2 <== NOT EXECUTED
handle->dirty = false; handle->bnum = 0; handle->buffer = NULL;
3a678: e58d6068 str r6, [sp, #104] ; 0x68 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3a67c: e5cd6060 strb r6, [sp, #96] ; 0x60 <== NOT EXECUTED
handle->bnum = 0;
3a680: e58d6064 str r6, [sp, #100] ; 0x64 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
3a684: ebfffb6a bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
3a688: eaffffe0 b 3a610 <rtems_rfs_dir_lookup_ino+0x3c> <== NOT EXECUTED
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a68c: e3a06801 mov r6, #65536 ; 0x10000 <== NOT EXECUTED 3a690: e58d9008 str r9, [sp, #8] <== NOT EXECUTED 3a694: e2466001 sub r6, r6, #1 <== NOT EXECUTED 3a698: e1a0a007 mov sl, r7 <== NOT EXECUTED 3a69c: e1a09008 mov r9, r8 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
3a6a0: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 3a6a4: e3520000 cmp r2, #0 <== NOT EXECUTED 3a6a8: 1a00005b bne 3a81c <rtems_rfs_dir_lookup_ino+0x248> <== NOT EXECUTED 3a6ac: e59d206c ldr r2, [sp, #108] ; 0x6c <== NOT EXECUTED 3a6b0: e3520000 cmp r2, #0 <== NOT EXECUTED 3a6b4: 0a00005a beq 3a824 <rtems_rfs_dir_lookup_ino+0x250> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: block read, ino=%" PRIu32 " bno=%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno);
rc = rtems_rfs_buffer_handle_request (fs, &entries, block, true);
3a6b8: e1a00004 mov r0, r4 <== NOT EXECUTED 3a6bc: e28d1060 add r1, sp, #96 ; 0x60 <== NOT EXECUTED 3a6c0: e3a03001 mov r3, #1 <== NOT EXECUTED 3a6c4: ebfffce2 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
3a6c8: e3500000 cmp r0, #0 <== NOT EXECUTED 3a6cc: e58d000c str r0, [sp, #12] <== NOT EXECUTED 3a6d0: ca000040 bgt 3a7d8 <rtems_rfs_dir_lookup_ino+0x204> <== NOT EXECUTED
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a6d4: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
3a6d8: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a6dc: e353000a cmp r3, #10 <== NOT EXECUTED
/*
* Search the block to see if the name matches. A hash of 0xffff or 0x0
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
3a6e0: e59d3068 ldr r3, [sp, #104] ; 0x68 <== NOT EXECUTED
map.bpos.boff = 0;
3a6e4: e58d2024 str r2, [sp, #36] ; 0x24 <== NOT EXECUTED
/*
* Search the block to see if the name matches. A hash of 0xffff or 0x0
* means the entry is empty.
*/
entry = rtems_rfs_buffer_data (&entries);
3a6e8: e5937020 ldr r7, [r3, #32] <== NOT EXECUTED
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a6ec: 1a000008 bne 3a714 <rtems_rfs_dir_lookup_ino+0x140> <== NOT EXECUTED 3a6f0: ea000035 b 3a7cc <rtems_rfs_dir_lookup_ino+0x1f8> <== NOT EXECUTED 3a6f4: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
3a6f8: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a6fc: e242200a sub r2, r2, #10 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
3a700: e0883003 add r3, r8, r3 <== NOT EXECUTED
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a704: e1520003 cmp r2, r3 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
return 0;
}
}
map.bpos.boff += elength;
3a708: e58d3024 str r3, [sp, #36] ; 0x24 <== NOT EXECUTED
entry = rtems_rfs_buffer_data (&entries);
map.bpos.boff = 0;
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
3a70c: 9a00002e bls 3a7cc <rtems_rfs_dir_lookup_ino+0x1f8> <== NOT EXECUTED
return 0;
}
}
map.bpos.boff += elength;
entry += elength;
3a710: e0877008 add r7, r7, r8 <== NOT EXECUTED
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
3a714: e5d72000 ldrb r2, [r7] <== NOT EXECUTED
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
3a718: e5d70009 ldrb r0, [r7, #9] <== NOT EXECUTED
*ino = rtems_rfs_dir_entry_ino (entry);
3a71c: e5d73003 ldrb r3, [r7, #3] <== NOT EXECUTED
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
3a720: e5d78008 ldrb r8, [r7, #8] <== NOT EXECUTED
*ino = rtems_rfs_dir_entry_ino (entry);
3a724: e5d71001 ldrb r1, [r7, #1] <== NOT EXECUTED 3a728: e1833c02 orr r3, r3, r2, lsl #24 <== NOT EXECUTED
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
3a72c: e1808408 orr r8, r0, r8, lsl #8 <== NOT EXECUTED
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
3a730: e5d70005 ldrb r0, [r7, #5] <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
3a734: e1833801 orr r3, r3, r1, lsl #16 <== NOT EXECUTED
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
3a738: e5d71004 ldrb r1, [r7, #4] <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
3a73c: e5d72002 ldrb r2, [r7, #2] <== NOT EXECUTED
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
3a740: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED 3a744: e1800c01 orr r0, r0, r1, lsl #24 <== NOT EXECUTED
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
3a748: e5d71007 ldrb r1, [r7, #7] <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
3a74c: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
while (map.bpos.boff < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE))
{
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
3a750: e5d72006 ldrb r2, [r7, #6] <== NOT EXECUTED
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
3a754: e1801001 orr r1, r0, r1 <== NOT EXECUTED
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a758: e1580006 cmp r8, r6 <== NOT EXECUTED
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
3a75c: e1811402 orr r1, r1, r2, lsl #8 <== NOT EXECUTED
uint32_t ehash;
int elength;
ehash = rtems_rfs_dir_entry_hash (entry);
elength = rtems_rfs_dir_entry_length (entry);
*ino = rtems_rfs_dir_entry_ino (entry);
3a760: e5853000 str r3, [r5] <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
3a764: 0a000018 beq 3a7cc <rtems_rfs_dir_lookup_ino+0x1f8> <== NOT EXECUTED
break;
if (rtems_rfs_dir_entry_valid (fs, elength, *ino))
3a768: e358000a cmp r8, #10 <== NOT EXECUTED 3a76c: da00002e ble 3a82c <rtems_rfs_dir_lookup_ino+0x258> <== NOT EXECUTED 3a770: e594c018 ldr ip, [r4, #24] <== NOT EXECUTED 3a774: e158000c cmp r8, ip <== NOT EXECUTED 3a778: 2a00002b bcs 3a82c <rtems_rfs_dir_lookup_ino+0x258> <== NOT EXECUTED 3a77c: e3530000 cmp r3, #0 <== NOT EXECUTED 3a780: 0a000029 beq 3a82c <rtems_rfs_dir_lookup_ino+0x258> <== NOT EXECUTED 3a784: e5942010 ldr r2, [r4, #16] <== NOT EXECUTED 3a788: e1530002 cmp r3, r2 <== NOT EXECUTED 3a78c: 8a000026 bhi 3a82c <rtems_rfs_dir_lookup_ino+0x258> <== NOT EXECUTED
rtems_rfs_inode_ino (inode), elength, *ino, map.bpos.boff);
rc = EIO;
break;
}
if (ehash == hash)
3a790: e15a0001 cmp sl, r1 <== NOT EXECUTED 3a794: 1affffd6 bne 3a6f4 <rtems_rfs_dir_lookup_ino+0x120> <== NOT EXECUTED
"checking entry for ino %" PRId32 ": bno=%04" PRIx32 "/off=%04" PRIx32
" length:%d ino:%" PRId32 "\n",
rtems_rfs_inode_ino (inode), map.bpos.bno, map.bpos.boff,
elength, rtems_rfs_dir_entry_ino (entry));
if (memcmp (entry + RTEMS_RFS_DIR_ENTRY_SIZE, name, length) == 0)
3a798: e287000a add r0, r7, #10 <== NOT EXECUTED 3a79c: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 3a7a0: e1a02009 mov r2, r9 <== NOT EXECUTED 3a7a4: eb002e97 bl 46208 <memcmp> <== NOT EXECUTED 3a7a8: e3500000 cmp r0, #0 <== NOT EXECUTED 3a7ac: 1affffd0 bne 3a6f4 <rtems_rfs_dir_lookup_ino+0x120> <== NOT EXECUTED
{
*offset = rtems_rfs_block_map_pos (fs, &map);
3a7b0: e1a00004 mov r0, r4 <== NOT EXECUTED 3a7b4: e28b1010 add r1, fp, #16 <== NOT EXECUTED 3a7b8: e59d9008 ldr r9, [sp, #8] <== NOT EXECUTED 3a7bc: ebfff822 bl 3884c <rtems_rfs_block_get_pos> <== NOT EXECUTED 3a7c0: e59d3098 ldr r3, [sp, #152] ; 0x98 <== NOT EXECUTED 3a7c4: e5830000 str r0, [r3] <== NOT EXECUTED 3a7c8: ea000003 b 3a7dc <rtems_rfs_dir_lookup_ino+0x208> <== NOT EXECUTED
map.bpos.boff += elength;
entry += elength;
}
if (rc == 0)
3a7cc: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 3a7d0: e35c0000 cmp ip, #0 <== NOT EXECUTED 3a7d4: 0a000007 beq 3a7f8 <rtems_rfs_dir_lookup_ino+0x224> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
3a7d8: e59d900c ldr r9, [sp, #12] <== NOT EXECUTED
printf ("rtems-rfs: dir-lookup-ino: block is 0 in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
}
rtems_rfs_buffer_handle_close (fs, &entries);
3a7dc: e28d1060 add r1, sp, #96 ; 0x60 <== NOT EXECUTED 3a7e0: e1a00004 mov r0, r4 <== NOT EXECUTED 3a7e4: ebfffd26 bl 39c84 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
3a7e8: e1a00004 mov r0, r4 <== NOT EXECUTED 3a7ec: e1a0100b mov r1, fp <== NOT EXECUTED 3a7f0: ebfffb0f bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
3a7f4: eaffff85 b 3a610 <rtems_rfs_dir_lookup_ino+0x3c> <== NOT EXECUTED
entry += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
3a7f8: e1a00004 mov r0, r4 <== NOT EXECUTED 3a7fc: e1a0100b mov r1, fp <== NOT EXECUTED 3a800: e28d206c add r2, sp, #108 ; 0x6c <== NOT EXECUTED 3a804: ebfff8b6 bl 38ae4 <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
3a808: e3500006 cmp r0, #6 <== NOT EXECUTED
entry += elength;
}
if (rc == 0)
{
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
3a80c: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_LOOKUP_INO))
printf ("rtems-rfs: dir-lookup-ino: "
"block map next block failed in ino %" PRIu32 ": %d: %s\n",
rtems_rfs_inode_ino (inode), rc, strerror (rc));
}
if (rc == ENXIO)
3a810: 1affffa2 bne 3a6a0 <rtems_rfs_dir_lookup_ino+0xcc> <== NOT EXECUTED 3a814: e3a09002 mov r9, #2 <== NOT EXECUTED 3a818: eaffffef b 3a7dc <rtems_rfs_dir_lookup_ino+0x208> <== NOT EXECUTED 3a81c: e59d9008 ldr r9, [sp, #8] <== NOT EXECUTED 3a820: eaffffed b 3a7dc <rtems_rfs_dir_lookup_ino+0x208> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &entries);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
while ((rc == 0) && block)
3a824: e3a09005 mov r9, #5 <== NOT EXECUTED 3a828: eaffffeb b 3a7dc <rtems_rfs_dir_lookup_ino+0x208> <== NOT EXECUTED 3a82c: e3a03005 mov r3, #5 <== NOT EXECUTED 3a830: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3a834: eaffffe7 b 3a7d8 <rtems_rfs_dir_lookup_ino+0x204> <== NOT EXECUTED
00039ca4 <rtems_rfs_dir_read>:
rtems_rfs_dir_read (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_pos_rel offset,
struct dirent* dirent,
size_t* length)
{
39ca4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
39ca8: e24dd074 sub sp, sp, #116 ; 0x74 <== NOT EXECUTED
39cac: e59d509c ldr r5, [sp, #156] ; 0x9c <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
rtems_rfs_inode_ino (dir), offset);
*length = 0;
39cb0: e3a0c000 mov ip, #0 <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
39cb4: e28d6014 add r6, sp, #20 <== NOT EXECUTED
rtems_rfs_dir_read (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_pos_rel offset,
struct dirent* dirent,
size_t* length)
{
39cb8: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 39cbc: e58d300c str r3, [sp, #12] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
rtems_rfs_inode_ino (dir), offset);
*length = 0;
39cc0: e585c000 str ip, [r5] <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
39cc4: e1a02006 mov r2, r6 <== NOT EXECUTED
rtems_rfs_dir_read (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* dir,
rtems_rfs_pos_rel offset,
struct dirent* dirent,
size_t* length)
{
39cc8: e1a04000 mov r4, r0 <== NOT EXECUTED
printf ("rtems-rfs: dir-read: dir=%" PRId32 " offset=%" PRId64 "\n",
rtems_rfs_inode_ino (dir), offset);
*length = 0;
rc = rtems_rfs_block_map_open (fs, dir, &map);
39ccc: ebfffe4b bl 39600 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
39cd0: e2508000 subs r8, r0, #0 <== NOT EXECUTED 39cd4: da000002 ble 39ce4 <rtems_rfs_dir_read+0x40> <== NOT EXECUTED
}
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
39cd8: e1a00008 mov r0, r8 <== NOT EXECUTED
39cdc: e28dd074 add sp, sp, #116 ; 0x74 <== NOT EXECUTED
39ce0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
39ce4: e5947008 ldr r7, [r4, #8] <== NOT EXECUTED 39ce8: e3a08000 mov r8, #0 <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
39cec: e1a02007 mov r2, r7 <== NOT EXECUTED
39cf0: e1a03008 mov r3, r8 <== NOT EXECUTED
39cf4: e28d1008 add r1, sp, #8 <== NOT EXECUTED
39cf8: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
39cfc: eb008743 bl 5ba10 <__moddi3> <== NOT EXECUTED
39d00: e1a02007 mov r2, r7 <== NOT EXECUTED
39d04: e1a03008 mov r3, r8 <== NOT EXECUTED
39d08: e0522000 subs r2, r2, r0 <== NOT EXECUTED
39d0c: e0c33001 sbc r3, r3, r1 <== NOT EXECUTED
39d10: e3530000 cmp r3, #0 <== NOT EXECUTED
39d14: da00000e ble 39d54 <rtems_rfs_dir_read+0xb0> <== NOT EXECUTED
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
39d18: e1a00004 mov r0, r4 <== NOT EXECUTED
39d1c: e1a01006 mov r1, r6 <== NOT EXECUTED
39d20: e28d3008 add r3, sp, #8 <== NOT EXECUTED
39d24: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
39d28: e28d9070 add r9, sp, #112 ; 0x70 <== NOT EXECUTED
39d2c: e58d9000 str r9, [sp] <== NOT EXECUTED
39d30: ebfffb78 bl 38b18 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
39d34: e2508000 subs r8, r0, #0 <== NOT EXECUTED 39d38: da000017 ble 39d9c <rtems_rfs_dir_read+0xf8> <== NOT EXECUTED
{
if (rc == ENXIO)
39d3c: e3580006 cmp r8, #6 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
39d40: e1a00004 mov r0, r4 <== NOT EXECUTED 39d44: e1a01006 mov r1, r6 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
rc = rtems_rfs_block_map_seek (fs, &map, offset, &block);
if (rc > 0)
{
if (rc == ENXIO)
39d48: 03a08002 moveq r8, #2 <== NOT EXECUTED
rc = ENOENT;
rtems_rfs_block_map_close (fs, &map);
39d4c: ebfffdb8 bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
39d50: eaffffe0 b 39cd8 <rtems_rfs_dir_read+0x34> <== NOT EXECUTED
rc = rtems_rfs_block_map_open (fs, dir, &map);
if (rc > 0)
return rc;
if (((rtems_rfs_fs_block_size (fs) -
39d54: 1a000001 bne 39d60 <rtems_rfs_dir_read+0xbc> <== NOT EXECUTED 39d58: e352000a cmp r2, #10 <== NOT EXECUTED 39d5c: 8affffed bhi 39d18 <rtems_rfs_dir_read+0x74> <== NOT EXECUTED
(offset % rtems_rfs_fs_block_size (fs))) <= RTEMS_RFS_DIR_ENTRY_SIZE))
offset = (((offset / rtems_rfs_fs_block_size (fs)) + 1) *
39d60: e28d1008 add r1, sp, #8 <== NOT EXECUTED
39d64: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
39d68: e1a02007 mov r2, r7 <== NOT EXECUTED
39d6c: e1a03008 mov r3, r8 <== NOT EXECUTED
39d70: eb0085fc bl 5b568 <__divdi3> <== NOT EXECUTED
39d74: e3a02001 mov r2, #1 <== NOT EXECUTED
39d78: e0922000 adds r2, r2, r0 <== NOT EXECUTED
39d7c: e3a03000 mov r3, #0 <== NOT EXECUTED
39d80: e0a33001 adc r3, r3, r1 <== NOT EXECUTED
39d84: e0810792 umull r0, r1, r2, r7 <== NOT EXECUTED
39d88: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
39d8c: e58d100c str r1, [sp, #12] <== NOT EXECUTED
39d90: e0211397 mla r1, r7, r3, r1 <== NOT EXECUTED
39d94: e58d100c str r1, [sp, #12] <== NOT EXECUTED
39d98: eaffffde b 39d18 <rtems_rfs_dir_read+0x74> <== NOT EXECUTED
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
39d9c: e3a0c801 mov ip, #65536 ; 0x10000 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
39da0: e3a03000 mov r3, #0 <== NOT EXECUTED 39da4: e24cc001 sub ip, ip, #1 <== NOT EXECUTED
handle->bnum = 0; handle->buffer = NULL;
39da8: e58d306c str r3, [sp, #108] ; 0x6c <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
39dac: e5cd3064 strb r3, [sp, #100] ; 0x64 <== NOT EXECUTED
handle->bnum = 0;
39db0: e58d3068 str r3, [sp, #104] ; 0x68 <== NOT EXECUTED 39db4: e58dc010 str ip, [sp, #16] <== NOT EXECUTED 39db8: ea000001 b 39dc4 <rtems_rfs_dir_read+0x120> <== NOT EXECUTED
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
39dbc: e3500000 cmp r0, #0 <== NOT EXECUTED 39dc0: 1a000027 bne 39e64 <rtems_rfs_dir_read+0x1c0> <== NOT EXECUTED
uint8_t* entry;
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
39dc4: e28d1064 add r1, sp, #100 ; 0x64 <== NOT EXECUTED 39dc8: e59d2070 ldr r2, [sp, #112] ; 0x70 <== NOT EXECUTED 39dcc: e3a03001 mov r3, #1 <== NOT EXECUTED 39dd0: e1a00004 mov r0, r4 <== NOT EXECUTED 39dd4: ebffff1e bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
39dd8: e2508000 subs r8, r0, #0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
39ddc: e1a01006 mov r1, r6 <== NOT EXECUTED 39de0: e28d2070 add r2, sp, #112 ; 0x70 <== NOT EXECUTED 39de4: e1a00004 mov r0, r4 <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
39de8: ca000024 bgt 39e80 <rtems_rfs_dir_read+0x1dc> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_block_map_close (fs, &map);
return rc;
}
entry = rtems_rfs_buffer_data (&buffer);
39dec: e59d306c ldr r3, [sp, #108] ; 0x6c <== NOT EXECUTED 39df0: e593c020 ldr ip, [r3, #32] <== NOT EXECUTED
entry += map.bpos.boff;
39df4: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 39df8: e08c7003 add r7, ip, r3 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
39dfc: e7dca003 ldrb sl, [ip, r3] <== NOT EXECUTED 39e00: e5d79003 ldrb r9, [r7, #3] <== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
39e04: e5d7c009 ldrb ip, [r7, #9] <== NOT EXECUTED 39e08: e5d7e008 ldrb lr, [r7, #8] <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
39e0c: e5d7b001 ldrb fp, [r7, #1] <== NOT EXECUTED 39e10: e189ac0a orr sl, r9, sl, lsl #24 <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
39e14: e59d9010 ldr r9, [sp, #16] <== NOT EXECUTED
}
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
39e18: e18ce40e orr lr, ip, lr, lsl #8 <== NOT EXECUTED
eino = rtems_rfs_dir_entry_ino (entry);
39e1c: e5d7c002 ldrb ip, [r7, #2] <== NOT EXECUTED 39e20: e18aa80b orr sl, sl, fp, lsl #16 <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
39e24: e15e0009 cmp lr, r9 <== NOT EXECUTED
entry = rtems_rfs_buffer_data (&buffer);
entry += map.bpos.boff;
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
39e28: e18aa40c orr sl, sl, ip, lsl #8 <== NOT EXECUTED 39e2c: e2879001 add r9, r7, #1 <== NOT EXECUTED 39e30: e287b002 add fp, r7, #2 <== NOT EXECUTED 39e34: e287c003 add ip, r7, #3 <== NOT EXECUTED
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
39e38: 1a000016 bne 39e98 <rtems_rfs_dir_read+0x1f4> <== NOT EXECUTED
printf ("rtems-rfs: dir-read: found off:%" PRIdoff_t " ino:%ld name=%s\n",
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
}
*length += rtems_rfs_fs_block_size (fs) - map.bpos.boff;
39e3c: e594e008 ldr lr, [r4, #8] <== NOT EXECUTED 39e40: e595c000 ldr ip, [r5] <== NOT EXECUTED 39e44: e063300e rsb r3, r3, lr <== NOT EXECUTED 39e48: e08c3003 add r3, ip, r3 <== NOT EXECUTED 39e4c: e5853000 str r3, [r5] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
39e50: ebfffb23 bl 38ae4 <rtems_rfs_block_map_next_block> <== NOT EXECUTED
if (rc == ENXIO)
39e54: e3500006 cmp r0, #6 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: next block: off:%" PRId64 " length:%zd\n",
offset, *length);
rc = rtems_rfs_block_map_next_block (fs, &map, &block);
39e58: e1a08000 mov r8, r0 <== NOT EXECUTED
if (rc == ENXIO)
39e5c: 1affffd6 bne 39dbc <rtems_rfs_dir_read+0x118> <== NOT EXECUTED 39e60: e3a08002 mov r8, #2 <== NOT EXECUTED
rc = ENOENT;
}
rtems_rfs_buffer_handle_close (fs, &buffer);
39e64: e28d1064 add r1, sp, #100 ; 0x64 <== NOT EXECUTED 39e68: e1a00004 mov r0, r4 <== NOT EXECUTED 39e6c: ebffff84 bl 39c84 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
39e70: e1a00004 mov r0, r4 <== NOT EXECUTED 39e74: e1a01006 mov r1, r6 <== NOT EXECUTED 39e78: ebfffd6d bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
39e7c: eaffff95 b 39cd8 <rtems_rfs_dir_read+0x34> <== NOT EXECUTED
int remaining;
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &buffer);
39e80: e28d1064 add r1, sp, #100 ; 0x64 <== NOT EXECUTED 39e84: ebffff7e bl 39c84 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
39e88: e1a00004 mov r0, r4 <== NOT EXECUTED 39e8c: e1a01006 mov r1, r6 <== NOT EXECUTED 39e90: ebfffd67 bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
return rc;
39e94: eaffff8f b 39cd8 <rtems_rfs_dir_read+0x34> <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
39e98: e35e000a cmp lr, #10 <== NOT EXECUTED 39e9c: e58db010 str fp, [sp, #16] <== NOT EXECUTED 39ea0: e1a0b00e mov fp, lr <== NOT EXECUTED 39ea4: ca000001 bgt 39eb0 <rtems_rfs_dir_read+0x20c> <== NOT EXECUTED
/*
* Look for an empty entry and if this is the last block that is the end of
* the directory.
*/
while (rc == 0)
39ea8: e3a08005 mov r8, #5 <== NOT EXECUTED 39eac: eaffffec b 39e64 <rtems_rfs_dir_read+0x1c0> <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (entry);
eino = rtems_rfs_dir_entry_ino (entry);
if (elength != RTEMS_RFS_DIR_ENTRY_EMPTY)
{
if (rtems_rfs_dir_entry_valid (fs, elength, eino))
39eb0: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED 39eb4: e35a0000 cmp sl, #0 <== NOT EXECUTED 39eb8: 115e0001 cmpne lr, r1 <== NOT EXECUTED 39ebc: 33a01000 movcc r1, #0 <== NOT EXECUTED 39ec0: 23a01001 movcs r1, #1 <== NOT EXECUTED 39ec4: 2afffff7 bcs 39ea8 <rtems_rfs_dir_read+0x204> <== NOT EXECUTED 39ec8: e5943010 ldr r3, [r4, #16] <== NOT EXECUTED 39ecc: e15a0003 cmp sl, r3 <== NOT EXECUTED 39ed0: 8afffff4 bhi 39ea8 <rtems_rfs_dir_read+0x204> <== NOT EXECUTED
rtems_rfs_inode_ino (dir), elength, eino, map.bpos.boff);
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
39ed4: e3a02e11 mov r2, #272 ; 0x110 <== NOT EXECUTED 39ed8: e59d0098 ldr r0, [sp, #152] ; 0x98 <== NOT EXECUTED 39edc: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 39ee0: eb003179 bl 464cc <memset> <== NOT EXECUTED
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
*length += elength;
39ee4: e5952000 ldr r2, [r5] <== NOT EXECUTED 39ee8: e08b2002 add r2, fp, r2 <== NOT EXECUTED 39eec: e5852000 str r2, [r5] <== NOT EXECUTED
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
39ef0: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 39ef4: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 39ef8: e0633001 rsb r3, r3, r1 <== NOT EXECUTED 39efc: e06b3003 rsb r3, fp, r3 <== NOT EXECUTED
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
39f00: e353000a cmp r3, #10 <== NOT EXECUTED
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
39f04: e28d1008 add r1, sp, #8 <== NOT EXECUTED
39f08: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
39f0c: e59de098 ldr lr, [sp, #152] ; 0x98 <== NOT EXECUTED
*length += elength;
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
*length += remaining;
39f10: d0833002 addle r3, r3, r2 <== NOT EXECUTED 39f14: d5853000 strle r3, [r5] <== NOT EXECUTED
rc = EIO;
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
39f18: e98e0003 stmib lr, {r0, r1} <== NOT EXECUTED
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
*length += remaining;
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
39f1c: e24b500a sub r5, fp, #10 <== NOT EXECUTED
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
39f20: e59d1098 ldr r1, [sp, #152] ; 0x98 <== NOT EXECUTED
*length += elength;
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
39f24: e59dc004 ldr ip, [sp, #4] <== NOT EXECUTED
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
39f28: e3a00e11 mov r0, #272 ; 0x110 <== NOT EXECUTED
remaining = rtems_rfs_fs_block_size (fs) - (map.bpos.boff + elength);
if (remaining <= RTEMS_RFS_DIR_ENTRY_SIZE)
*length += remaining;
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
39f2c: e35500ff cmp r5, #255 ; 0xff <== NOT EXECUTED 39f30: a3a050ff movge r5, #255 ; 0xff <== NOT EXECUTED
break;
}
memset (dirent, 0, sizeof (struct dirent));
dirent->d_off = offset;
dirent->d_reclen = sizeof (struct dirent);
39f34: e1ce00bc strh r0, [lr, #12] <== NOT EXECUTED
elength -= RTEMS_RFS_DIR_ENTRY_SIZE;
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
39f38: e1a02005 mov r2, r5 <== NOT EXECUTED 39f3c: e2810010 add r0, r1, #16 <== NOT EXECUTED 39f40: e287100a add r1, r7, #10 <== NOT EXECUTED 39f44: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 39f48: eb0030d8 bl 462b0 <memcpy> <== NOT EXECUTED
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
39f4c: e5d92000 ldrb r2, [r9] <== NOT EXECUTED 39f50: e59dc004 ldr ip, [sp, #4] <== NOT EXECUTED 39f54: e5d71000 ldrb r1, [r7] <== NOT EXECUTED 39f58: e59d9010 ldr r9, [sp, #16] <== NOT EXECUTED 39f5c: e5dc3000 ldrb r3, [ip] <== NOT EXECUTED 39f60: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED 39f64: e1821c01 orr r1, r2, r1, lsl #24 <== NOT EXECUTED 39f68: e5d92000 ldrb r2, [r9] <== NOT EXECUTED
dirent->d_namlen = elength;
39f6c: e59dc098 ldr ip, [sp, #152] ; 0x98 <== NOT EXECUTED
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
39f70: e1813003 orr r3, r1, r3 <== NOT EXECUTED 39f74: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
dirent->d_namlen = elength;
39f78: e1cc50be strh r5, [ip, #14] <== NOT EXECUTED
if (elength > NAME_MAX)
elength = NAME_MAX;
memcpy (dirent->d_name, entry + RTEMS_RFS_DIR_ENTRY_SIZE, elength);
dirent->d_ino = rtems_rfs_dir_entry_ino (entry);
39f7c: e58c3000 str r3, [ip] <== NOT EXECUTED
dirent->d_namlen = elength;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_DIR_READ))
printf ("rtems-rfs: dir-read: found off:%" PRIdoff_t " ino:%ld name=%s\n",
dirent->d_off, dirent->d_ino, dirent->d_name);
break;
39f80: eaffffb7 b 39e64 <rtems_rfs_dir_read+0x1c0> <== NOT EXECUTED
0003b190 <rtems_rfs_file_close>:
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
3b190: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3b194: e1a04001 mov r4, r1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: entry: ino=%" PRId32 "\n",
handle->shared->inode.ino);
if (handle->shared->references > 0)
3b198: e591101c ldr r1, [r1, #28] <== NOT EXECUTED 3b19c: e5913008 ldr r3, [r1, #8] <== NOT EXECUTED 3b1a0: e3530000 cmp r3, #0 <== NOT EXECUTED
handle->shared->references--;
3b1a4: c2433001 subgt r3, r3, #1 <== NOT EXECUTED 3b1a8: c5813008 strgt r3, [r1, #8] <== NOT EXECUTED
if (handle->shared->references == 0)
3b1ac: e3530000 cmp r3, #0 <== NOT EXECUTED
}
int
rtems_rfs_file_close (rtems_rfs_file_system* fs,
rtems_rfs_file_handle* handle)
{
3b1b0: e1a06000 mov r6, r0 <== NOT EXECUTED
handle->shared->inode.ino);
if (handle->shared->references > 0)
handle->shared->references--;
if (handle->shared->references == 0)
3b1b4: 13a05000 movne r5, #0 <== NOT EXECUTED 3b1b8: 1a00004b bne 3b2ec <rtems_rfs_file_close+0x15c> <== NOT EXECUTED
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
3b1bc: e5913018 ldr r3, [r1, #24] <== NOT EXECUTED 3b1c0: e3530000 cmp r3, #0 <== NOT EXECUTED 3b1c4: 0a000058 beq 3b32c <rtems_rfs_file_close+0x19c> <== NOT EXECUTED
if (rrc == 0)
{
/*
* @todo This could be clever and only update if different.
*/
rtems_rfs_inode_set_atime (&handle->shared->inode,
3b1c8: e591208c ldr r2, [r1, #140] ; 0x8c <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
3b1cc: e1a00c22 lsr r0, r2, #24 <== NOT EXECUTED 3b1d0: e5c30010 strb r0, [r3, #16] <== NOT EXECUTED 3b1d4: e5913018 ldr r3, [r1, #24] <== NOT EXECUTED 3b1d8: e1a00822 lsr r0, r2, #16 <== NOT EXECUTED 3b1dc: e5c30011 strb r0, [r3, #17] <== NOT EXECUTED 3b1e0: e5913018 ldr r3, [r1, #24] <== NOT EXECUTED 3b1e4: e1a00422 lsr r0, r2, #8 <== NOT EXECUTED 3b1e8: e5c30012 strb r0, [r3, #18] <== NOT EXECUTED 3b1ec: e5913018 ldr r3, [r1, #24] <== NOT EXECUTED 3b1f0: e5c32013 strb r2, [r3, #19] <== NOT EXECUTED
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
3b1f4: e594201c ldr r2, [r4, #28] <== NOT EXECUTED 3b1f8: e5923090 ldr r3, [r2, #144] ; 0x90 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
3b1fc: e592c018 ldr ip, [r2, #24] <== NOT EXECUTED
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3b200: e3a00001 mov r0, #1 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
3b204: e1a0ec23 lsr lr, r3, #24 <== NOT EXECUTED
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3b208: e5c1001c strb r0, [r1, #28] <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
3b20c: e5cce014 strb lr, [ip, #20] <== NOT EXECUTED 3b210: e5921018 ldr r1, [r2, #24] <== NOT EXECUTED 3b214: e1a0c823 lsr ip, r3, #16 <== NOT EXECUTED 3b218: e5c1c015 strb ip, [r1, #21] <== NOT EXECUTED 3b21c: e5921018 ldr r1, [r2, #24] <== NOT EXECUTED 3b220: e1a0c423 lsr ip, r3, #8 <== NOT EXECUTED 3b224: e5c1c016 strb ip, [r1, #22] <== NOT EXECUTED 3b228: e5921018 ldr r1, [r2, #24] <== NOT EXECUTED 3b22c: e5c13017 strb r3, [r1, #23] <== NOT EXECUTED
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
3b230: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3b234: e5931094 ldr r1, [r3, #148] ; 0x94 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
3b238: e593c018 ldr ip, [r3, #24] <== NOT EXECUTED 3b23c: e1a0ec21 lsr lr, r1, #24 <== NOT EXECUTED
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3b240: e5c2001c strb r0, [r2, #28] <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
3b244: e5cce018 strb lr, [ip, #24] <== NOT EXECUTED 3b248: e5932018 ldr r2, [r3, #24] <== NOT EXECUTED 3b24c: e1a0c821 lsr ip, r1, #16 <== NOT EXECUTED 3b250: e5c2c019 strb ip, [r2, #25] <== NOT EXECUTED 3b254: e5932018 ldr r2, [r3, #24] <== NOT EXECUTED 3b258: e1a0c421 lsr ip, r1, #8 <== NOT EXECUTED 3b25c: e5c2c01a strb ip, [r2, #26] <== NOT EXECUTED 3b260: e5932018 ldr r2, [r3, #24] <== NOT EXECUTED 3b264: e5c2101b strb r1, [r2, #27] <== NOT EXECUTED
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
3b268: e594101c ldr r1, [r4, #28] <== NOT EXECUTED 3b26c: e5912084 ldr r2, [r1, #132] ; 0x84 <== NOT EXECUTED 3b270: e591c03c ldr ip, [r1, #60] ; 0x3c <== NOT EXECUTED 3b274: e152000c cmp r2, ip <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3b278: e5c3001c strb r0, [r3, #28] <== NOT EXECUTED 3b27c: e1a03001 mov r3, r1 <== NOT EXECUTED 3b280: 15910088 ldrne r0, [r1, #136] ; 0x88 <== NOT EXECUTED 3b284: 0a000023 beq 3b318 <rtems_rfs_file_close+0x188> <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
3b288: e583203c str r2, [r3, #60] ; 0x3c <== NOT EXECUTED
map->dirty = true;
3b28c: e3a02001 mov r2, #1 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size (rtems_rfs_block_map* map,
rtems_rfs_block_size* size)
{
rtems_rfs_block_copy_size (&map->size, size);
3b290: e5830040 str r0, [r3, #64] ; 0x40 <== NOT EXECUTED
map->dirty = true;
3b294: e5c32034 strb r2, [r3, #52] ; 0x34 <== NOT EXECUTED 3b298: e1a01003 mov r1, r3 <== NOT EXECUTED 3b29c: e3a05000 mov r5, #0 <== NOT EXECUTED
&handle->shared->map.size))
rtems_rfs_block_map_set_size (&handle->shared->map,
&handle->shared->size);
}
rc = rtems_rfs_block_map_close (fs, &handle->shared->map);
3b2a0: e2811034 add r1, r1, #52 ; 0x34 <== NOT EXECUTED 3b2a4: e1a00006 mov r0, r6 <== NOT EXECUTED 3b2a8: ebfff861 bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
3b2ac: e3500000 cmp r0, #0 <== NOT EXECUTED 3b2b0: da000001 ble 3b2bc <rtems_rfs_file_close+0x12c> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: map close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
3b2b4: e3550000 cmp r5, #0 <== NOT EXECUTED 3b2b8: 01a05000 moveq r5, r0 <== NOT EXECUTED
rrc = rc;
}
rc = rtems_rfs_inode_close (fs, &handle->shared->inode);
3b2bc: e594101c ldr r1, [r4, #28] <== NOT EXECUTED 3b2c0: e1a00006 mov r0, r6 <== NOT EXECUTED 3b2c4: e281100c add r1, r1, #12 <== NOT EXECUTED 3b2c8: eb0007c1 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
3b2cc: e3500000 cmp r0, #0 <== NOT EXECUTED 3b2d0: da000001 ble 3b2dc <rtems_rfs_file_close+0x14c> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: inode close error: ino=%" PRId32 ": %d: %s\n",
handle->shared->inode.ino, rc, strerror (rc));
if (rrc == 0)
3b2d4: e3550000 cmp r5, #0 <== NOT EXECUTED 3b2d8: 01a05000 moveq r5, r0 <== NOT EXECUTED 3b2dc: e594001c ldr r0, [r4, #28] <== NOT EXECUTED 3b2e0: ebff4772 bl d0b0 <_Chain_Extract> <== NOT EXECUTED
rrc = rc;
}
rtems_chain_extract (&handle->shared->link);
free (handle->shared);
3b2e4: e594001c ldr r0, [r4, #28] <== NOT EXECUTED 3b2e8: ebff32a0 bl 7d70 <free> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3b2ec: e2841004 add r1, r4, #4 <== NOT EXECUTED 3b2f0: e1a00006 mov r0, r6 <== NOT EXECUTED 3b2f4: ebfff98c bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
3b2f8: e3a03000 mov r3, #0 <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_CLOSE))
printf ("rtems-rfs: file-close: result: %d: %s\n", rrc, strerror (rrc));
}
free (handle);
3b2fc: e1a00004 mov r0, r4 <== NOT EXECUTED
handle->bnum = 0; handle->buffer = NULL;
3b300: e584300c str r3, [r4, #12] <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3b304: e5c43004 strb r3, [r4, #4] <== NOT EXECUTED
handle->bnum = 0;
3b308: e5843008 str r3, [r4, #8] <== NOT EXECUTED 3b30c: ebff3297 bl 7d70 <free> <== NOT EXECUTED
return rrc;
}
3b310: e1a00005 mov r0, r5 <== NOT EXECUTED
3b314: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
handle->shared->atime);
rtems_rfs_inode_set_mtime (&handle->shared->inode,
handle->shared->mtime);
rtems_rfs_inode_set_ctime (&handle->shared->inode,
handle->shared->ctime);
if (!rtems_rfs_block_size_equal (&handle->shared->size,
3b318: e5910088 ldr r0, [r1, #136] ; 0x88 <== NOT EXECUTED 3b31c: e591c040 ldr ip, [r1, #64] ; 0x40 <== NOT EXECUTED 3b320: e150000c cmp r0, ip <== NOT EXECUTED 3b324: 1affffd7 bne 3b288 <rtems_rfs_file_close+0xf8> <== NOT EXECUTED 3b328: eaffffdb b 3b29c <rtems_rfs_file_close+0x10c> <== NOT EXECUTED
handle->shared->references--;
if (handle->shared->references == 0)
{
if (!rtems_rfs_inode_is_loaded (&handle->shared->inode))
rrc = rtems_rfs_inode_load (fs, &handle->shared->inode);
3b32c: e281100c add r1, r1, #12 <== NOT EXECUTED 3b330: eb0007b3 bl 3d204 <rtems_rfs_inode_load> <== NOT EXECUTED
if (rrc == 0)
3b334: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3b338: 1594101c ldrne r1, [r4, #28] <== NOT EXECUTED 3b33c: 1affffd7 bne 3b2a0 <rtems_rfs_file_close+0x110> <== NOT EXECUTED 3b340: e594101c ldr r1, [r4, #28] <== NOT EXECUTED 3b344: e5913018 ldr r3, [r1, #24] <== NOT EXECUTED 3b348: eaffff9e b 3b1c8 <rtems_rfs_file_close+0x38> <== NOT EXECUTED
0003aa14 <rtems_rfs_file_get_shared>:
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return the_chain->first;
3aa14: e5903070 ldr r3, [r0, #112] ; 0x70 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
3aa18: e2802074 add r2, r0, #116 ; 0x74 <== NOT EXECUTED
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
3aa1c: e1530002 cmp r3, r2 <== NOT EXECUTED 3aa20: 0a00000b beq 3aa54 <rtems_rfs_file_get_shared+0x40> <== NOT EXECUTED
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
3aa24: e5930014 ldr r0, [r3, #20] <== NOT EXECUTED 3aa28: e1500001 cmp r0, r1 <== NOT EXECUTED
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
3aa2c: e1a00003 mov r0, r3 <== NOT EXECUTED
if (shared->inode.ino == ino)
3aa30: 1a000004 bne 3aa48 <rtems_rfs_file_get_shared+0x34> <== NOT EXECUTED 3aa34: e12fff1e bx lr <== NOT EXECUTED 3aa38: e5930014 ldr r0, [r3, #20] <== NOT EXECUTED 3aa3c: e1500001 cmp r0, r1 <== NOT EXECUTED
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
3aa40: e1a00003 mov r0, r3 <== NOT EXECUTED
if (shared->inode.ino == ino)
3aa44: 012fff1e bxeq lr <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3aa48: e5933000 ldr r3, [r3] <== NOT EXECUTED
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
3aa4c: e1530002 cmp r3, r2 <== NOT EXECUTED 3aa50: 1afffff8 bne 3aa38 <rtems_rfs_file_get_shared+0x24> <== NOT EXECUTED 3aa54: e3a00000 mov r0, #0 <== NOT EXECUTED
if (shared->inode.ino == ino)
return shared;
node = rtems_chain_next (node);
}
return NULL;
}
3aa58: e12fff1e bx lr <== NOT EXECUTED
0003afd4 <rtems_rfs_file_io_end>:
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
3afd4: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
3afd8: e590400c ldr r4, [r0, #12] <== NOT EXECUTED 3afdc: e3540000 cmp r4, #0 <== NOT EXECUTED
int
rtems_rfs_file_io_end (rtems_rfs_file_handle* handle,
size_t size,
bool read)
{
3afe0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3afe4: e1a05000 mov r5, r0 <== NOT EXECUTED 3afe8: e1a07001 mov r7, r1 <== NOT EXECUTED 3afec: e20260ff and r6, r2, #255 ; 0xff <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: end: %s size=%zu\n",
read ? "read" : "write", size);
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
3aff0: 0a000017 beq 3b054 <rtems_rfs_file_io_end+0x80> <== NOT EXECUTED
{
if (!read)
3aff4: e3560000 cmp r6, #0 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
3aff8: 03a03001 moveq r3, #1 <== NOT EXECUTED 3affc: 05c03004 strbeq r3, [r0, #4] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
3b000: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 3b004: e2851004 add r1, r5, #4 <== NOT EXECUTED 3b008: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3b00c: ebfffa46 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
if (rc > 0)
3b010: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3b014: da00000e ble 3b054 <rtems_rfs_file_io_end+0x80> <== NOT EXECUTED
{
printf (
3b018: e59f3164 ldr r3, [pc, #356] ; 3b184 <rtems_rfs_file_io_end+0x1b0><== NOT EXECUTED 3b01c: e59f2164 ldr r2, [pc, #356] ; 3b188 <rtems_rfs_file_io_end+0x1b4><== NOT EXECUTED 3b020: e3560000 cmp r6, #0 <== NOT EXECUTED 3b024: 11a06002 movne r6, r2 <== NOT EXECUTED 3b028: 01a06003 moveq r6, r3 <== NOT EXECUTED 3b02c: eb003960 bl 495b4 <strerror> <== NOT EXECUTED 3b030: e1a01006 mov r1, r6 <== NOT EXECUTED 3b034: e58d0000 str r0, [sp] <== NOT EXECUTED 3b038: e1a02007 mov r2, r7 <== NOT EXECUTED 3b03c: e1a03004 mov r3, r4 <== NOT EXECUTED 3b040: e59f0144 ldr r0, [pc, #324] ; 3b18c <rtems_rfs_file_io_end+0x1b8><== NOT EXECUTED 3b044: eb003147 bl 47568 <printf> <== NOT EXECUTED
handle->shared->size.offset =
rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
}
return rc;
}
3b048: e1a00004 mov r0, r4 <== NOT EXECUTED
3b04c: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3b050: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
* increase the block number and adjust the offset. * * If we are the last block and the position is past the current size update * the size with the new length. The map holds the block count. */ handle->bpos.boff += size;
3b054: e5952014 ldr r2, [r5, #20] <== NOT EXECUTED
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
3b058: e595301c ldr r3, [r5, #28] <== NOT EXECUTED
* increase the block number and adjust the offset. * * If we are the last block and the position is past the current size update * the size with the new length. The map holds the block count. */ handle->bpos.boff += size;
3b05c: e0877002 add r7, r7, r2 <== NOT EXECUTED 3b060: e5857014 str r7, [r5, #20] <== NOT EXECUTED
if (handle->bpos.boff >=
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))
3b064: e5932098 ldr r2, [r3, #152] ; 0x98 <== NOT EXECUTED 3b068: e5921008 ldr r1, [r2, #8] <== NOT EXECUTED 3b06c: e1570001 cmp r7, r1 <== NOT EXECUTED 3b070: 3a000005 bcc 3b08c <rtems_rfs_file_io_end+0xb8> <== NOT EXECUTED
{
handle->bpos.bno++;
3b074: e5951010 ldr r1, [r5, #16] <== NOT EXECUTED 3b078: e2811001 add r1, r1, #1 <== NOT EXECUTED 3b07c: e5851010 str r1, [r5, #16] <== NOT EXECUTED
handle->bpos.boff -= rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
3b080: e5922008 ldr r2, [r2, #8] <== NOT EXECUTED 3b084: e0627007 rsb r7, r2, r7 <== NOT EXECUTED 3b088: e5857014 str r7, [r5, #20] <== NOT EXECUTED
}
length = false;
mtime = false;
if (!read &&
3b08c: e3560000 cmp r6, #0 <== NOT EXECUTED 3b090: 0a000019 beq 3b0fc <rtems_rfs_file_io_end+0x128> <== NOT EXECUTED 3b094: e3a08000 mov r8, #0 <== NOT EXECUTED 3b098: e1a07008 mov r7, r8 <== NOT EXECUTED
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
3b09c: e595a000 ldr sl, [r5] <== NOT EXECUTED
mtime = rtems_rfs_file_update_mtime (handle) && mtime;
3b0a0: e31a0002 tst sl, #2 <== NOT EXECUTED 3b0a4: 13a07000 movne r7, #0 <== NOT EXECUTED
length = rtems_rfs_file_update_length (handle) && length;
3b0a8: e31a0004 tst sl, #4 <== NOT EXECUTED
handle->bpos.boff);
length = true;
mtime = true;
}
atime = rtems_rfs_file_update_atime (handle);
3b0ac: e22aa001 eor sl, sl, #1 <== NOT EXECUTED
mtime = rtems_rfs_file_update_mtime (handle) && mtime; length = rtems_rfs_file_update_length (handle) && length;
3b0b0: 13a08000 movne r8, #0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: end: pos=%" PRIu32 ":%" PRIu32 " %c %c %c\n",
handle->bpos.bno, handle->bpos.boff,
atime ? 'A' : '-', mtime ? 'M' : '-', length ? 'L' : '-');
if (atime || mtime)
3b0b4: e21aa001 ands sl, sl, #1 <== NOT EXECUTED 3b0b8: 1a000001 bne 3b0c4 <rtems_rfs_file_io_end+0xf0> <== NOT EXECUTED 3b0bc: e3570000 cmp r7, #0 <== NOT EXECUTED 3b0c0: 0a000006 beq 3b0e0 <rtems_rfs_file_io_end+0x10c> <== NOT EXECUTED
{
time_t now = time (NULL);
3b0c4: e3a00000 mov r0, #0 <== NOT EXECUTED 3b0c8: eb004f3a bl 4edb8 <time> <== NOT EXECUTED
if (read && atime)
3b0cc: e3560000 cmp r6, #0 <== NOT EXECUTED 3b0d0: 0a000017 beq 3b134 <rtems_rfs_file_io_end+0x160> <== NOT EXECUTED 3b0d4: e35a0000 cmp sl, #0 <== NOT EXECUTED
handle->shared->atime = now;
3b0d8: 1595301c ldrne r3, [r5, #28] <== NOT EXECUTED 3b0dc: 1583008c strne r0, [r3, #140] ; 0x8c <== NOT EXECUTED
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
3b0e0: e3580000 cmp r8, #0 <== NOT EXECUTED
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
3b0e4: 1595301c ldrne r3, [r5, #28] <== NOT EXECUTED
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
3b0e8: 1593203c ldrne r2, [r3, #60] ; 0x3c <== NOT EXECUTED
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
3b0ec: 15931040 ldrne r1, [r3, #64] ; 0x40 <== NOT EXECUTED
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
3b0f0: 15832084 strne r2, [r3, #132] ; 0x84 <== NOT EXECUTED
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
3b0f4: 15831088 strne r1, [r3, #136] ; 0x88 <== NOT EXECUTED 3b0f8: eaffffd2 b 3b048 <rtems_rfs_file_io_end+0x74> <== NOT EXECUTED
length = false;
mtime = false;
if (!read &&
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
3b0fc: e5952010 ldr r2, [r5, #16] <== NOT EXECUTED
}
length = false;
mtime = false;
if (!read &&
3b100: e3520000 cmp r2, #0 <== NOT EXECUTED 3b104: 0593103c ldreq r1, [r3, #60] ; 0x3c <== NOT EXECUTED 3b108: 0a000013 beq 3b15c <rtems_rfs_file_io_end+0x188> <== NOT EXECUTED
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
3b10c: e593103c ldr r1, [r3, #60] ; 0x3c <== NOT EXECUTED
}
length = false;
mtime = false;
if (!read &&
3b110: e3510000 cmp r1, #0 <== NOT EXECUTED 3b114: 1a000010 bne 3b15c <rtems_rfs_file_io_end+0x188> <== NOT EXECUTED 3b118: e5951014 ldr r1, [r5, #20] <== NOT EXECUTED 3b11c: e3a02001 mov r2, #1 <== NOT EXECUTED 3b120: e1a08002 mov r8, r2 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
3b124: e5831040 str r1, [r3, #64] ; 0x40 <== NOT EXECUTED
map->dirty = true;
3b128: e5c32034 strb r2, [r3, #52] ; 0x34 <== NOT EXECUTED 3b12c: e1a07002 mov r7, r2 <== NOT EXECUTED 3b130: eaffffd9 b 3b09c <rtems_rfs_file_io_end+0xc8> <== NOT EXECUTED
if (atime || mtime)
{
time_t now = time (NULL);
if (read && atime)
handle->shared->atime = now;
if (!read && mtime)
3b134: e3570000 cmp r7, #0 <== NOT EXECUTED
handle->shared->mtime = now;
3b138: 1595301c ldrne r3, [r5, #28] <== NOT EXECUTED 3b13c: 15830090 strne r0, [r3, #144] ; 0x90 <== NOT EXECUTED
} if (length)
3b140: e3580000 cmp r8, #0 <== NOT EXECUTED
{
handle->shared->size.count =
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
3b144: 1595301c ldrne r3, [r5, #28] <== NOT EXECUTED
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
3b148: 1593203c ldrne r2, [r3, #60] ; 0x3c <== NOT EXECUTED
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
3b14c: 15931040 ldrne r1, [r3, #64] ; 0x40 <== NOT EXECUTED
if (!read && mtime)
handle->shared->mtime = now;
}
if (length)
{
handle->shared->size.count =
3b150: 15832084 strne r2, [r3, #132] ; 0x84 <== NOT EXECUTED
rtems_rfs_block_map_count (rtems_rfs_file_map (handle));
handle->shared->size.offset =
3b154: 15831088 strne r1, [r3, #136] ; 0x88 <== NOT EXECUTED 3b158: eaffffba b 3b048 <rtems_rfs_file_io_end+0x74> <== NOT EXECUTED
}
length = false;
mtime = false;
if (!read &&
3b15c: e1520001 cmp r2, r1 <== NOT EXECUTED 3b160: 2affffec bcs 3b118 <rtems_rfs_file_io_end+0x144> <== NOT EXECUTED 3b164: e2411001 sub r1, r1, #1 <== NOT EXECUTED 3b168: e1520001 cmp r2, r1 <== NOT EXECUTED 3b16c: 1affffc8 bne 3b094 <rtems_rfs_file_io_end+0xc0> <== NOT EXECUTED
rtems_rfs_block_map_past_end (rtems_rfs_file_map (handle),
3b170: e5951014 ldr r1, [r5, #20] <== NOT EXECUTED
}
length = false;
mtime = false;
if (!read &&
3b174: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED 3b178: e1510002 cmp r1, r2 <== NOT EXECUTED 3b17c: 9affffc4 bls 3b094 <rtems_rfs_file_io_end+0xc0> <== NOT EXECUTED 3b180: eaffffe5 b 3b11c <rtems_rfs_file_io_end+0x148> <== NOT EXECUTED
0003abc0 <rtems_rfs_file_io_release>:
int
rtems_rfs_file_io_release (rtems_rfs_file_handle* handle)
{
int rc = 0;
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
3abc0: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 3abc4: e3530000 cmp r3, #0 <== NOT EXECUTED 3abc8: 0a000003 beq 3abdc <rtems_rfs_file_io_release+0x1c> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
3abcc: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 3abd0: e2801004 add r1, r0, #4 <== NOT EXECUTED 3abd4: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3abd8: eafffb53 b 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
return rc;
}
3abdc: e1a00003 mov r0, r3 <== NOT EXECUTED 3abe0: e12fff1e bx lr <== NOT EXECUTED
0003aa5c <rtems_rfs_file_io_start>:
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
3aa5c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
3aa60: e590600c ldr r6, [r0, #12] <== NOT EXECUTED 3aa64: e3560000 cmp r6, #0 <== NOT EXECUTED
int
rtems_rfs_file_io_start (rtems_rfs_file_handle* handle,
size_t* available,
bool read)
{
3aa68: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3aa6c: e1a04000 mov r4, r0 <== NOT EXECUTED 3aa70: e1a07001 mov r7, r1 <== NOT EXECUTED 3aa74: e20250ff and r5, r2, #255 ; 0xff <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: %s pos=%" PRIu32 ":%" PRIu32 "\n",
read ? "read" : "write", handle->bpos.bno, handle->bpos.boff);
if (!rtems_rfs_buffer_handle_has_block (&handle->buffer))
3aa78: 0a00001a beq 3aae8 <rtems_rfs_file_io_start+0x8c> <== NOT EXECUTED
block, request_read);
if (rc > 0)
return rc;
}
if (read
3aa7c: e3550000 cmp r5, #0 <== NOT EXECUTED 3aa80: 0594301c ldreq r3, [r4, #28] <== NOT EXECUTED 3aa84: 1a000007 bne 3aaa8 <rtems_rfs_file_io_start+0x4c> <== NOT EXECUTED
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
size = rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle));
else
size = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
3aa88: e5933098 ldr r3, [r3, #152] ; 0x98 <== NOT EXECUTED 3aa8c: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED
*available = size - rtems_rfs_file_block_offset (handle);
3aa90: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3aa94: e0632002 rsb r2, r3, r2 <== NOT EXECUTED 3aa98: e5872000 str r2, [r7] <== NOT EXECUTED 3aa9c: e3a00000 mov r0, #0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: available=%zu (%zu)\n",
*available, size);
return 0;
}
3aaa0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3aaa4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
if (rc > 0)
return rc;
}
if (read
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
3aaa8: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3aaac: e5932044 ldr r2, [r3, #68] ; 0x44 <== NOT EXECUTED
block, request_read);
if (rc > 0)
return rc;
}
if (read
3aab0: e3520000 cmp r2, #0 <== NOT EXECUTED 3aab4: 1593103c ldrne r1, [r3, #60] ; 0x3c <== NOT EXECUTED 3aab8: 1a000006 bne 3aad8 <rtems_rfs_file_io_start+0x7c> <== NOT EXECUTED
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
3aabc: e593103c ldr r1, [r3, #60] ; 0x3c <== NOT EXECUTED
block, request_read);
if (rc > 0)
return rc;
}
if (read
3aac0: e3510000 cmp r1, #0 <== NOT EXECUTED 3aac4: 1a000003 bne 3aad8 <rtems_rfs_file_io_start+0x7c> <== NOT EXECUTED
&& rtems_rfs_block_map_last (rtems_rfs_file_map (handle))
&& rtems_rfs_block_map_size_offset (rtems_rfs_file_map (handle)))
3aac8: e5932040 ldr r2, [r3, #64] ; 0x40 <== NOT EXECUTED
block, request_read);
if (rc > 0)
return rc;
}
if (read
3aacc: e3520000 cmp r2, #0 <== NOT EXECUTED 3aad0: 1affffee bne 3aa90 <rtems_rfs_file_io_start+0x34> <== NOT EXECUTED 3aad4: eaffffeb b 3aa88 <rtems_rfs_file_io_start+0x2c> <== NOT EXECUTED 3aad8: e2411001 sub r1, r1, #1 <== NOT EXECUTED 3aadc: e1520001 cmp r2, r1 <== NOT EXECUTED 3aae0: 1affffe8 bne 3aa88 <rtems_rfs_file_io_start+0x2c> <== NOT EXECUTED 3aae4: eafffff7 b 3aac8 <rtems_rfs_file_io_start+0x6c> <== NOT EXECUTED
bool request_read;
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
3aae8: e590301c ldr r3, [r0, #28] <== NOT EXECUTED 3aaec: e2842010 add r2, r4, #16 <== NOT EXECUTED 3aaf0: e2831034 add r1, r3, #52 ; 0x34 <== NOT EXECUTED 3aaf4: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3aaf8: e1a0300d mov r3, sp <== NOT EXECUTED 3aafc: ebfff79d bl 38978 <rtems_rfs_block_map_find> <== NOT EXECUTED
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
3ab00: e3500000 cmp r0, #0 <== NOT EXECUTED
bool request_read;
int rc;
request_read = read;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
3ab04: e1a0800d mov r8, sp <== NOT EXECUTED
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
3ab08: da000005 ble 3ab24 <rtems_rfs_file_io_start+0xc8> <== NOT EXECUTED
{
/*
* Has the read reached the EOF ?
*/
if (read && (rc == ENXIO))
3ab0c: e3550000 cmp r5, #0 <== NOT EXECUTED 3ab10: 0a00000e beq 3ab50 <rtems_rfs_file_io_start+0xf4> <== NOT EXECUTED 3ab14: e3500006 cmp r0, #6 <== NOT EXECUTED
{
*available = 0;
3ab18: 05876000 streq r6, [r7] <== NOT EXECUTED 3ab1c: 01a00006 moveq r0, r6 <== NOT EXECUTED 3ab20: eaffffde b 3aaa0 <rtems_rfs_file_io_start+0x44> <== NOT EXECUTED
/*
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
3ab24: e3550000 cmp r5, #0 <== NOT EXECUTED 3ab28: 0a000016 beq 3ab88 <rtems_rfs_file_io_start+0x12c> <== NOT EXECUTED 3ab2c: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3ab30: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3ab34: e3a03001 mov r3, #1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: block=%" PRIu32 " request-read=%s\n",
block, request_read ? "yes" : "no");
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
3ab38: e2841004 add r1, r4, #4 <== NOT EXECUTED 3ab3c: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3ab40: ebfffbc3 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
rtems_rfs_file_buffer (handle),
block, request_read);
if (rc > 0)
3ab44: e3500000 cmp r0, #0 <== NOT EXECUTED 3ab48: caffffd4 bgt 3aaa0 <rtems_rfs_file_io_start+0x44> <== NOT EXECUTED 3ab4c: eaffffca b 3aa7c <rtems_rfs_file_io_start+0x20> <== NOT EXECUTED
{
*available = 0;
return 0;
}
if (rc != ENXIO)
3ab50: e3500006 cmp r0, #6 <== NOT EXECUTED 3ab54: 1affffd1 bne 3aaa0 <rtems_rfs_file_io_start+0x44> <== NOT EXECUTED
return rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_IO))
printf ("rtems-rfs: file-io: start: grow\n");
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
3ab58: e594201c ldr r2, [r4, #28] <== NOT EXECUTED 3ab5c: e1a0300d mov r3, sp <== NOT EXECUTED 3ab60: e2821034 add r1, r2, #52 ; 0x34 <== NOT EXECUTED 3ab64: e5920098 ldr r0, [r2, #152] ; 0x98 <== NOT EXECUTED 3ab68: e3a02001 mov r2, #1 <== NOT EXECUTED 3ab6c: ebfff937 bl 39050 <rtems_rfs_block_map_grow> <== NOT EXECUTED
rtems_rfs_file_map (handle),
1, &block);
if (rc > 0)
3ab70: e3500000 cmp r0, #0 <== NOT EXECUTED 3ab74: caffffc9 bgt 3aaa0 <rtems_rfs_file_io_start+0x44> <== NOT EXECUTED 3ab78: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3ab7c: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3ab80: e1a03005 mov r3, r5 <== NOT EXECUTED 3ab84: eaffffeb b 3ab38 <rtems_rfs_file_io_start+0xdc> <== NOT EXECUTED
* If this is a write check if the write starts within a block or the
* amount of data is less than a block size. If it is read the block
* rather than getting a block to fill.
*/
if (!read &&
(rtems_rfs_file_block_offset (handle) ||
3ab88: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED 3ab8c: e3530000 cmp r3, #0 <== NOT EXECUTED 3ab90: 1594301c ldrne r3, [r4, #28] <== NOT EXECUTED 3ab94: 1a000006 bne 3abb4 <rtems_rfs_file_io_start+0x158> <== NOT EXECUTED
(*available < rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle)))))
3ab98: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3ab9c: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3aba0: e5971000 ldr r1, [r7] <== NOT EXECUTED 3aba4: e5902008 ldr r2, [r0, #8] <== NOT EXECUTED 3aba8: e1510002 cmp r1, r2 <== NOT EXECUTED 3abac: 21a03005 movcs r3, r5 <== NOT EXECUTED 3abb0: 2affffe0 bcs 3ab38 <rtems_rfs_file_io_start+0xdc> <== NOT EXECUTED 3abb4: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3abb8: e3a03001 mov r3, #1 <== NOT EXECUTED 3abbc: eaffffdd b 3ab38 <rtems_rfs_file_io_start+0xdc> <== NOT EXECUTED
0003b34c <rtems_rfs_file_open>:
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
uint32_t flags,
rtems_rfs_file_handle** file)
{
3b34c: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
*file = NULL;
3b350: e3a04000 mov r4, #0 <== NOT EXECUTED
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
uint32_t flags,
rtems_rfs_file_handle** file)
{
3b354: e1a08000 mov r8, r0 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 "\n", ino);
*file = NULL;
3b358: e5834000 str r4, [r3] <== NOT EXECUTED
/* * Allocate a new handle and initialise it. Do this before we deal with the * shared node data so we do not have to be concerned with reference * counting. */ handle = malloc (sizeof (rtems_rfs_file_handle));
3b35c: e3a00020 mov r0, #32 <== NOT EXECUTED
int
rtems_rfs_file_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
uint32_t flags,
rtems_rfs_file_handle** file)
{
3b360: e1a07003 mov r7, r3 <== NOT EXECUTED 3b364: e1a0a001 mov sl, r1 <== NOT EXECUTED 3b368: e1a09002 mov r9, r2 <== NOT EXECUTED
/* * Allocate a new handle and initialise it. Do this before we deal with the * shared node data so we do not have to be concerned with reference * counting. */ handle = malloc (sizeof (rtems_rfs_file_handle));
3b36c: ebff3443 bl 8480 <malloc> <== NOT EXECUTED
if (!handle)
3b370: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3b374: 0a00002b beq 3b428 <rtems_rfs_file_open+0xdc> <== NOT EXECUTED
return ENOMEM;
memset (handle, 0, sizeof (rtems_rfs_file_handle));
3b378: e1a06005 mov r6, r5 <== NOT EXECUTED 3b37c: e4864004 str r4, [r6], #4 <== NOT EXECUTED 3b380: e2863008 add r3, r6, #8 <== NOT EXECUTED 3b384: e5854004 str r4, [r5, #4] <== NOT EXECUTED 3b388: e4834004 str r4, [r3], #4 <== NOT EXECUTED 3b38c: e4834004 str r4, [r3], #4 <== NOT EXECUTED 3b390: e4834004 str r4, [r3], #4 <== NOT EXECUTED 3b394: e4834004 str r4, [r3], #4 <== NOT EXECUTED 3b398: e5834000 str r4, [r3] <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_First(
Chain_Control *the_chain
)
{
return the_chain->first;
3b39c: e5983070 ldr r3, [r8, #112] ; 0x70 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Tail(
Chain_Control *the_chain
)
{
return (Chain_Node *) &the_chain->permanent_null;
3b3a0: e2881074 add r1, r8, #116 ; 0x74 <== NOT EXECUTED
rtems_rfs_file_get_shared (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
3b3a4: e1530001 cmp r3, r1 <== NOT EXECUTED
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
handle->buffer = NULL;
3b3a8: e585400c str r4, [r5, #12] <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
3b3ac: e5854008 str r4, [r5, #8] <== NOT EXECUTED 3b3b0: 1a000003 bne 3b3c4 <rtems_rfs_file_open+0x78> <== NOT EXECUTED 3b3b4: ea00000f b 3b3f8 <rtems_rfs_file_open+0xac> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE Chain_Node *_Chain_Next(
Chain_Node *the_node
)
{
return the_node->next;
3b3b8: e5933000 ldr r3, [r3] <== NOT EXECUTED 3b3bc: e1530001 cmp r3, r1 <== NOT EXECUTED 3b3c0: 0a00000c beq 3b3f8 <rtems_rfs_file_open+0xac> <== NOT EXECUTED
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
if (shared->inode.ino == ino)
3b3c4: e5932014 ldr r2, [r3, #20] <== NOT EXECUTED 3b3c8: e15a0002 cmp sl, r2 <== NOT EXECUTED
rtems_chain_node* node;
node = rtems_chain_first (&fs->file_shares);
while (!rtems_chain_is_tail (&fs->file_shares, node))
{
rtems_rfs_file_shared* shared;
shared = (rtems_rfs_file_shared*) node;
3b3cc: e1a04003 mov r4, r3 <== NOT EXECUTED
if (shared->inode.ino == ino)
3b3d0: 1afffff8 bne 3b3b8 <rtems_rfs_file_open+0x6c> <== NOT EXECUTED
* the reference count and return the pointer to the data.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
if (shared)
{
shared->references++;
3b3d4: e5932008 ldr r2, [r3, #8] <== NOT EXECUTED 3b3d8: e2822001 add r2, r2, #1 <== NOT EXECUTED 3b3dc: e5832008 str r2, [r3, #8] <== NOT EXECUTED
}
handle->flags = flags;
handle->shared = shared;
*file = handle;
3b3e0: e5875000 str r5, [r7] <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: ino=%" PRId32 " share created\n", ino);
}
handle->flags = flags;
3b3e4: e5859000 str r9, [r5] <== NOT EXECUTED
handle->shared = shared;
3b3e8: e585401c str r4, [r5, #28] <== NOT EXECUTED
*file = handle;
3b3ec: e3a0a000 mov sl, #0 <== NOT EXECUTED
return 0;
}
3b3f0: e1a0000a mov r0, sl <== NOT EXECUTED
3b3f4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
{
/*
* None exists so create. Copy in the shared parts of the inode we hold in
* memory.
*/
shared = malloc (sizeof (rtems_rfs_file_shared));
3b3f8: e3a0009c mov r0, #156 ; 0x9c <== NOT EXECUTED 3b3fc: ebff341f bl 8480 <malloc> <== NOT EXECUTED
if (!shared)
3b400: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3b404: 1a00000a bne 3b434 <rtems_rfs_file_open+0xe8> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3b408: e1a01006 mov r1, r6 <== NOT EXECUTED 3b40c: e1a00008 mov r0, r8 <== NOT EXECUTED 3b410: ebfff945 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false; handle->bnum = 0; handle->buffer = NULL;
3b414: e585400c str r4, [r5, #12] <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3b418: e5c54004 strb r4, [r5, #4] <== NOT EXECUTED
handle->bnum = 0;
3b41c: e5854008 str r4, [r5, #8] <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
3b420: e1a00005 mov r0, r5 <== NOT EXECUTED 3b424: ebff3251 bl 7d70 <free> <== NOT EXECUTED 3b428: e3a0a00c mov sl, #12 <== NOT EXECUTED
handle->shared = shared;
*file = handle;
return 0;
}
3b42c: e1a0000a mov r0, sl <== NOT EXECUTED
3b430: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
3b434: e3a01000 mov r1, #0 <== NOT EXECUTED 3b438: e3a0209c mov r2, #156 ; 0x9c <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
3b43c: e284b00c add fp, r4, #12 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return ENOMEM;
}
memset (shared, 0, sizeof (rtems_rfs_file_shared));
3b440: eb002c21 bl 464cc <memset> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &shared->inode, true);
3b444: e1a0100a mov r1, sl <== NOT EXECUTED 3b448: e1a00008 mov r0, r8 <== NOT EXECUTED 3b44c: e1a0200b mov r2, fp <== NOT EXECUTED 3b450: e3a03001 mov r3, #1 <== NOT EXECUTED 3b454: eb000782 bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
3b458: e250a000 subs sl, r0, #0 <== NOT EXECUTED 3b45c: da00000b ble 3b490 <rtems_rfs_file_open+0x144> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
free (shared);
3b460: e1a00004 mov r0, r4 <== NOT EXECUTED 3b464: ebff3241 bl 7d70 <free> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3b468: e1a00008 mov r0, r8 <== NOT EXECUTED 3b46c: e1a01006 mov r1, r6 <== NOT EXECUTED 3b470: ebfff92d bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
3b474: e3a03000 mov r3, #0 <== NOT EXECUTED
handle->bnum = 0; handle->buffer = NULL;
3b478: e585300c str r3, [r5, #12] <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3b47c: e5c53004 strb r3, [r5, #4] <== NOT EXECUTED
handle->bnum = 0;
3b480: e5853008 str r3, [r5, #8] <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
3b484: e1a00005 mov r0, r5 <== NOT EXECUTED 3b488: ebff3238 bl 7d70 <free> <== NOT EXECUTED
return rc;
3b48c: eaffffd7 b 3b3f0 <rtems_rfs_file_open+0xa4> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
rc = rtems_rfs_block_map_open (fs, &shared->inode, &shared->map);
3b490: e1a00008 mov r0, r8 <== NOT EXECUTED 3b494: e1a0100b mov r1, fp <== NOT EXECUTED 3b498: e2842034 add r2, r4, #52 ; 0x34 <== NOT EXECUTED 3b49c: ebfff857 bl 39600 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
3b4a0: e250a000 subs sl, r0, #0 <== NOT EXECUTED 3b4a4: da000003 ble 3b4b8 <rtems_rfs_file_open+0x16c> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
printf ("rtems-rfs: file-open: block map open failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &shared->inode);
3b4a8: e1a0100b mov r1, fp <== NOT EXECUTED 3b4ac: e1a00008 mov r0, r8 <== NOT EXECUTED 3b4b0: eb000747 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED 3b4b4: eaffffe9 b 3b460 <rtems_rfs_file_open+0x114> <== NOT EXECUTED
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
3b4b8: e5943018 ldr r3, [r4, #24] <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle->buffer);
free (handle);
return rc;
}
shared->references = 1;
3b4bc: e3a02001 mov r2, #1 <== NOT EXECUTED 3b4c0: e5842008 str r2, [r4, #8] <== NOT EXECUTED 3b4c4: e283200c add r2, r3, #12 <== NOT EXECUTED
shared->size.count = rtems_rfs_inode_get_block_count (&shared->inode);
3b4c8: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED 3b4cc: e5d3000c ldrb r0, [r3, #12] <== NOT EXECUTED 3b4d0: e5d2c001 ldrb ip, [r2, #1] <== NOT EXECUTED 3b4d4: e1810c00 orr r0, r1, r0, lsl #24 <== NOT EXECUTED 3b4d8: e5d21002 ldrb r1, [r2, #2] <== NOT EXECUTED 3b4dc: e180280c orr r2, r0, ip, lsl #16 <== NOT EXECUTED 3b4e0: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED 3b4e4: e5842084 str r2, [r4, #132] ; 0x84 <== NOT EXECUTED
shared->size.offset = rtems_rfs_inode_get_block_offset (&shared->inode);
3b4e8: e5d3100a ldrb r1, [r3, #10] <== NOT EXECUTED 3b4ec: e5d3200b ldrb r2, [r3, #11] <== NOT EXECUTED 3b4f0: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED 3b4f4: e5842088 str r2, [r4, #136] ; 0x88 <== NOT EXECUTED
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
3b4f8: e2832010 add r2, r3, #16 <== NOT EXECUTED
shared->atime = rtems_rfs_inode_get_atime (&shared->inode);
3b4fc: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED 3b500: e5d30010 ldrb r0, [r3, #16] <== NOT EXECUTED 3b504: e5d2c001 ldrb ip, [r2, #1] <== NOT EXECUTED 3b508: e1810c00 orr r0, r1, r0, lsl #24 <== NOT EXECUTED 3b50c: e5d21002 ldrb r1, [r2, #2] <== NOT EXECUTED 3b510: e180280c orr r2, r0, ip, lsl #16 <== NOT EXECUTED 3b514: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED 3b518: e584208c str r2, [r4, #140] ; 0x8c <== NOT EXECUTED
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
3b51c: e2832014 add r2, r3, #20 <== NOT EXECUTED
shared->mtime = rtems_rfs_inode_get_mtime (&shared->inode);
3b520: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED 3b524: e5d30014 ldrb r0, [r3, #20] <== NOT EXECUTED 3b528: e5d2c001 ldrb ip, [r2, #1] <== NOT EXECUTED 3b52c: e1810c00 orr r0, r1, r0, lsl #24 <== NOT EXECUTED 3b530: e5d21002 ldrb r1, [r2, #2] <== NOT EXECUTED 3b534: e180280c orr r2, r0, ip, lsl #16 <== NOT EXECUTED 3b538: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED 3b53c: e5842090 str r2, [r4, #144] ; 0x90 <== NOT EXECUTED
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
3b540: e2832018 add r2, r3, #24 <== NOT EXECUTED
shared->ctime = rtems_rfs_inode_get_ctime (&shared->inode);
3b544: e5d30018 ldrb r0, [r3, #24] <== NOT EXECUTED 3b548: e5d23003 ldrb r3, [r2, #3] <== NOT EXECUTED 3b54c: e5d21001 ldrb r1, [r2, #1] <== NOT EXECUTED 3b550: e1833c00 orr r3, r3, r0, lsl #24 <== NOT EXECUTED 3b554: e5d22002 ldrb r2, [r2, #2] <== NOT EXECUTED 3b558: e1833801 orr r3, r3, r1, lsl #16 <== NOT EXECUTED 3b55c: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void rtems_chain_append(
rtems_chain_control *the_chain,
rtems_chain_node *the_node
)
{
_Chain_Append( the_chain, the_node );
3b560: e2880070 add r0, r8, #112 ; 0x70 <== NOT EXECUTED 3b564: e1a01004 mov r1, r4 <== NOT EXECUTED 3b568: e5843094 str r3, [r4, #148] ; 0x94 <== NOT EXECUTED
shared->fs = fs;
3b56c: e5848098 str r8, [r4, #152] ; 0x98 <== NOT EXECUTED 3b570: ebff46c3 bl d084 <_Chain_Append> <== NOT EXECUTED
rtems_chain_append (&fs->file_shares, &shared->link);
rtems_rfs_inode_unload (fs, &shared->inode, false);
3b574: e1a00008 mov r0, r8 <== NOT EXECUTED 3b578: e1a0100b mov r1, fp <== NOT EXECUTED 3b57c: e3a02000 mov r2, #0 <== NOT EXECUTED 3b580: eb0006e8 bl 3d128 <rtems_rfs_inode_unload> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_FILE_OPEN))
3b584: eaffff95 b 3b3e0 <rtems_rfs_file_open+0x94> <== NOT EXECUTED
0003af00 <rtems_rfs_file_seek>:
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
3af00: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3af04: e1a04000 mov r4, r0 <== NOT EXECUTED
* file, this function does not itself extend the size of the file." * * This means the file needs to set the file size to the pos only when a * write occurs. */ if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
3af08: e590001c ldr r0, [r0, #28] <== NOT EXECUTED
int
rtems_rfs_file_seek (rtems_rfs_file_handle* handle,
rtems_rfs_pos pos,
rtems_rfs_pos* new_pos)
{
3af0c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3af10: e1a06001 mov r6, r1 <== NOT EXECUTED 3af14: e2801084 add r1, r0, #132 ; 0x84 <== NOT EXECUTED 3af18: e5900098 ldr r0, [r0, #152] ; 0x98 <== NOT EXECUTED 3af1c: e1a05002 mov r5, r2 <== NOT EXECUTED 3af20: e1a07003 mov r7, r3 <== NOT EXECUTED 3af24: ebfff664 bl 388bc <rtems_rfs_block_get_size> <== NOT EXECUTED
* file, this function does not itself extend the size of the file." * * This means the file needs to set the file size to the pos only when a * write occurs. */ if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
3af28: e1510005 cmp r1, r5 <== NOT EXECUTED 3af2c: 8a000008 bhi 3af54 <rtems_rfs_file_seek+0x54> <== NOT EXECUTED 3af30: 0a000005 beq 3af4c <rtems_rfs_file_seek+0x4c> <== NOT EXECUTED
{
/*
* The seek is outside the current file so release any buffer. A write will
* extend the file.
*/
int rc = rtems_rfs_file_io_release (handle);
3af34: e1a00004 mov r0, r4 <== NOT EXECUTED 3af38: ebffff20 bl 3abc0 <rtems_rfs_file_io_release> <== NOT EXECUTED
if (rc > 0)
3af3c: e3500000 cmp r0, #0 <== NOT EXECUTED 3af40: da00001f ble 3afc4 <rtems_rfs_file_seek+0xc4> <== NOT EXECUTED
return rc;
}
*new_pos = pos;
return 0;
}
3af44: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3af48: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
* file, this function does not itself extend the size of the file." * * This means the file needs to set the file size to the pos only when a * write occurs. */ if (pos < rtems_rfs_file_shared_get_size (rtems_rfs_file_fs (handle),
3af4c: e1500006 cmp r0, r6 <== NOT EXECUTED 3af50: 9afffff7 bls 3af34 <rtems_rfs_file_seek+0x34> <== NOT EXECUTED
handle->shared))
{
rtems_rfs_file_set_bpos (handle, pos);
3af54: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3af58: e2848010 add r8, r4, #16 <== NOT EXECUTED 3af5c: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3af60: e1a01006 mov r1, r6 <== NOT EXECUTED 3af64: e1a03008 mov r3, r8 <== NOT EXECUTED 3af68: e1a02005 mov r2, r5 <== NOT EXECUTED 3af6c: ebfff623 bl 38800 <rtems_rfs_block_get_bpos> <== NOT EXECUTED
/*
* If the file has a block check if it maps to the current position and it
* does not release it. That will force us to get the block at the new
* position when the I/O starts.
*/
if (rtems_rfs_buffer_handle_has_block (&handle->buffer))
3af70: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3af74: e3530000 cmp r3, #0 <== NOT EXECUTED 3af78: 0a000011 beq 3afc4 <rtems_rfs_file_seek+0xc4> <== NOT EXECUTED
{
rtems_rfs_buffer_block block;
int rc;
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
3af7c: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3af80: e1a02008 mov r2, r8 <== NOT EXECUTED 3af84: e2831034 add r1, r3, #52 ; 0x34 <== NOT EXECUTED 3af88: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3af8c: e1a0300d mov r3, sp <== NOT EXECUTED 3af90: ebfff678 bl 38978 <rtems_rfs_block_map_find> <== NOT EXECUTED
rtems_rfs_file_map (handle),
rtems_rfs_file_bpos (handle),
&block);
if (rc > 0)
3af94: e3500000 cmp r0, #0 <== NOT EXECUTED 3af98: caffffe9 bgt 3af44 <rtems_rfs_file_seek+0x44> <== NOT EXECUTED
return rc;
if (rtems_rfs_buffer_bnum (&handle->buffer) != block)
3af9c: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 3afa0: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3afa4: e1520003 cmp r2, r3 <== NOT EXECUTED 3afa8: 0a000005 beq 3afc4 <rtems_rfs_file_seek+0xc4> <== NOT EXECUTED
{
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
3afac: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3afb0: e2841004 add r1, r4, #4 <== NOT EXECUTED 3afb4: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3afb8: ebfffa5b bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
if (rc > 0)
3afbc: e3500000 cmp r0, #0 <== NOT EXECUTED 3afc0: caffffdf bgt 3af44 <rtems_rfs_file_seek+0x44> <== NOT EXECUTED
int rc = rtems_rfs_file_io_release (handle);
if (rc > 0)
return rc;
}
*new_pos = pos;
3afc4: e5875004 str r5, [r7, #4] <== NOT EXECUTED 3afc8: e5876000 str r6, [r7] <== NOT EXECUTED 3afcc: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
3afd0: eaffffdb b 3af44 <rtems_rfs_file_seek+0x44> <== NOT EXECUTED
0003abe4 <rtems_rfs_file_set_size>:
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
3abe4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
3abe8: e590501c ldr r5, [r0, #28] <== NOT EXECUTED
}
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
3abec: e1a0a001 mov sl, r1 <== NOT EXECUTED 3abf0: e24dd018 sub sp, sp, #24 <== NOT EXECUTED 3abf4: e1a04000 mov r4, r0 <== NOT EXECUTED 3abf8: e2851084 add r1, r5, #132 ; 0x84 <== NOT EXECUTED 3abfc: e5950098 ldr r0, [r5, #152] ; 0x98 <== NOT EXECUTED 3ac00: e1a0b002 mov fp, r2 <== NOT EXECUTED 3ac04: ebfff72c bl 388bc <rtems_rfs_block_get_size> <== NOT EXECUTED
/* * If the file is same size do nothing else grow or shrink it ? * * If the file does not change size do not update the times. */ if (size != new_size)
3ac08: e15a0000 cmp sl, r0 <== NOT EXECUTED 3ac0c: 0a0000ab beq 3aec0 <rtems_rfs_file_set_size+0x2dc> <== NOT EXECUTED
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
3ac10: e19a200b orrs r2, sl, fp <== NOT EXECUTED
int
rtems_rfs_file_set_size (rtems_rfs_file_handle* handle,
rtems_rfs_pos new_size)
{
rtems_rfs_block_map* map = rtems_rfs_file_map (handle);
3ac14: e2859034 add r9, r5, #52 ; 0x34 <== NOT EXECUTED
if (size != new_size)
{
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
3ac18: 0a000083 beq 3ae2c <rtems_rfs_file_set_size+0x248> <== NOT EXECUTED
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
3ac1c: e15b0001 cmp fp, r1 <== NOT EXECUTED 3ac20: 9a000054 bls 3ad78 <rtems_rfs_file_set_size+0x194> <== NOT EXECUTED
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
3ac24: e594c01c ldr ip, [r4, #28] <== NOT EXECUTED
*/
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
3ac28: e1a0700a mov r7, sl <== NOT EXECUTED 3ac2c: e1a0800b mov r8, fp <== NOT EXECUTED 3ac30: e0577000 subs r7, r7, r0 <== NOT EXECUTED 3ac34: e0c88001 sbc r8, r8, r1 <== NOT EXECUTED
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
3ac38: e59c0098 ldr r0, [ip, #152] ; 0x98 <== NOT EXECUTED
read_block = false;
while (count)
3ac3c: e1973008 orrs r3, r7, r8 <== NOT EXECUTED
rtems_rfs_pos count;
uint32_t length;
bool read_block;
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
3ac40: e5906008 ldr r6, [r0, #8] <== NOT EXECUTED
read_block = false;
while (count)
3ac44: 0a00009b beq 3aeb8 <rtems_rfs_file_set_size+0x2d4> <== NOT EXECUTED
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
3ac48: e3a02000 mov r2, #0 <== NOT EXECUTED 3ac4c: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3ac50: e284b004 add fp, r4, #4 <== NOT EXECUTED
/*
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
3ac54: e1a0a002 mov sl, r2 <== NOT EXECUTED 3ac58: ea000025 b 3acf4 <rtems_rfs_file_set_size+0x110> <== NOT EXECUTED
map, 1, &block);
if (rc > 0)
return rc;
}
if (count < (length - bpos.boff))
3ac5c: e1520007 cmp r2, r7 <== NOT EXECUTED 3ac60: 9a00003f bls 3ad64 <rtems_rfs_file_set_size+0x180> <== NOT EXECUTED
{
length = count + bpos.boff;
3ac64: e0836007 add r6, r3, r7 <== NOT EXECUTED
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
map->dirty = true;
3ac68: e3a02001 mov r2, #1 <== NOT EXECUTED 3ac6c: e3a03001 mov r3, #1 <== NOT EXECUTED 3ac70: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
3ac74: e5856040 str r6, [r5, #64] ; 0x40 <== NOT EXECUTED
map->dirty = true;
3ac78: e5c52034 strb r2, [r5, #52] ; 0x34 <== NOT EXECUTED
}
/*
* Only read the block if the length is not the block size.
*/
rc = rtems_rfs_buffer_handle_request (rtems_rfs_file_fs (handle),
3ac7c: e594201c ldr r2, [r4, #28] <== NOT EXECUTED 3ac80: e1a0100b mov r1, fp <== NOT EXECUTED 3ac84: e5920098 ldr r0, [r2, #152] ; 0x98 <== NOT EXECUTED 3ac88: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 3ac8c: ebfffb70 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
rtems_rfs_file_buffer (handle),
block, read_block);
if (rc > 0)
3ac90: e3500000 cmp r0, #0 <== NOT EXECUTED 3ac94: ca000062 bgt 3ae24 <rtems_rfs_file_set_size+0x240> <== NOT EXECUTED
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
memset (dst + bpos.boff, 0, length - bpos.boff);
3ac98: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3ac9c: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 3aca0: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 3aca4: e3a01000 mov r1, #0 <== NOT EXECUTED 3aca8: e0632006 rsb r2, r3, r6 <== NOT EXECUTED 3acac: e0800003 add r0, r0, r3 <== NOT EXECUTED 3acb0: eb002e05 bl 464cc <memset> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
3acb4: e594301c ldr r3, [r4, #28] <== NOT EXECUTED
return rc;
dst = rtems_rfs_buffer_data (&handle->buffer);
memset (dst + bpos.boff, 0, length - bpos.boff);
rtems_rfs_buffer_mark_dirty (rtems_rfs_file_buffer (handle));
3acb8: e3a02001 mov r2, #1 <== NOT EXECUTED 3acbc: e5c42004 strb r2, [r4, #4] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (rtems_rfs_file_fs (handle),
3acc0: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3acc4: e1a0100b mov r1, fp <== NOT EXECUTED 3acc8: ebfffb17 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_file_buffer (handle));
if (rc > 0)
3accc: e3500000 cmp r0, #0 <== NOT EXECUTED 3acd0: ca000053 bgt 3ae24 <rtems_rfs_file_set_size+0x240> <== NOT EXECUTED
return rc;
count -= length - bpos.boff;
3acd4: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 3acd8: e0633006 rsb r3, r3, r6 <== NOT EXECUTED 3acdc: e0577003 subs r7, r7, r3 <== NOT EXECUTED 3ace0: e2c88000 sbc r8, r8, #0 <== NOT EXECUTED
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
3ace4: e1973008 orrs r3, r7, r8 <== NOT EXECUTED 3ace8: 0a000055 beq 3ae44 <rtems_rfs_file_set_size+0x260> <== NOT EXECUTED 3acec: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3acf0: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
/*
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
3acf4: e595203c ldr r2, [r5, #60] ; 0x3c <== NOT EXECUTED 3acf8: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 3acfc: e5953040 ldr r3, [r5, #64] ; 0x40 <== NOT EXECUTED 3ad00: e3530000 cmp r3, #0 <== NOT EXECUTED 3ad04: 12422001 subne r2, r2, #1 <== NOT EXECUTED 3ad08: 158d2008 strne r2, [sp, #8] <== NOT EXECUTED 3ad0c: e58d300c str r3, [sp, #12] <== NOT EXECUTED
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
3ad10: e1a01009 mov r1, r9 <== NOT EXECUTED 3ad14: e28d2008 add r2, sp, #8 <== NOT EXECUTED 3ad18: e28d3014 add r3, sp, #20 <== NOT EXECUTED
/*
* Get the block position for the current end of the file as seen by
* the map. If not found and the EOF grow the map then fill the block
* with 0.
*/
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map), &bpos);
3ad1c: e58da010 str sl, [sp, #16] <== NOT EXECUTED
rc = rtems_rfs_block_map_find (rtems_rfs_file_fs (handle),
3ad20: ebfff714 bl 38978 <rtems_rfs_block_map_find> <== NOT EXECUTED
map, &bpos, &block);
if (rc > 0)
3ad24: e3500000 cmp r0, #0 <== NOT EXECUTED 3ad28: da000009 ble 3ad54 <rtems_rfs_file_set_size+0x170> <== NOT EXECUTED
{
/*
* Have we reached the EOF ?
*/
if (rc != ENXIO)
3ad2c: e3500006 cmp r0, #6 <== NOT EXECUTED 3ad30: 1a00003b bne 3ae24 <rtems_rfs_file_set_size+0x240> <== NOT EXECUTED
return rc;
rc = rtems_rfs_block_map_grow (rtems_rfs_file_fs (handle),
3ad34: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3ad38: e1a01009 mov r1, r9 <== NOT EXECUTED 3ad3c: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3ad40: e3a02001 mov r2, #1 <== NOT EXECUTED 3ad44: e28d3014 add r3, sp, #20 <== NOT EXECUTED 3ad48: ebfff8c0 bl 39050 <rtems_rfs_block_map_grow> <== NOT EXECUTED
map, 1, &block);
if (rc > 0)
3ad4c: e3500000 cmp r0, #0 <== NOT EXECUTED 3ad50: ca000033 bgt 3ae24 <rtems_rfs_file_set_size+0x240> <== NOT EXECUTED
return rc;
}
if (count < (length - bpos.boff))
3ad54: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 3ad58: e15a0008 cmp sl, r8 <== NOT EXECUTED 3ad5c: e0632006 rsb r2, r3, r6 <== NOT EXECUTED 3ad60: 0affffbd beq 3ac5c <rtems_rfs_file_set_size+0x78> <== NOT EXECUTED 3ad64: e3a03001 mov r3, #1 <== NOT EXECUTED 3ad68: e5c53034 strb r3, [r5, #52] ; 0x34 <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
3ad6c: e585a040 str sl, [r5, #64] ; 0x40 <== NOT EXECUTED
map->dirty = true;
3ad70: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 3ad74: eaffffc0 b 3ac7c <rtems_rfs_file_set_size+0x98> <== NOT EXECUTED
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
3ad78: 0a000040 beq 3ae80 <rtems_rfs_file_set_size+0x29c> <== NOT EXECUTED
uint32_t offset;
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
3ad7c: e594c01c ldr ip, [r4, #28] <== NOT EXECUTED 3ad80: e59c9098 ldr r9, [ip, #152] ; 0x98 <== NOT EXECUTED
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
3ad84: e3e00000 mvn r0, #0 <== NOT EXECUTED
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
3ad88: e5997008 ldr r7, [r9, #8] <== NOT EXECUTED
* Shrink
*/
rtems_rfs_block_no blocks;
uint32_t offset;
blocks =
3ad8c: e090000a adds r0, r0, sl <== NOT EXECUTED 3ad90: e3e01000 mvn r1, #0 <== NOT EXECUTED 3ad94: e0a1100b adc r1, r1, fp <== NOT EXECUTED 3ad98: e1a02007 mov r2, r7 <== NOT EXECUTED 3ad9c: e3a03000 mov r3, #0 <== NOT EXECUTED 3ada0: e58dc000 str ip, [sp] <== NOT EXECUTED 3ada4: eb00845b bl 5bf18 <__udivdi3> <== NOT EXECUTED 3ada8: e595603c ldr r6, [r5, #60] ; 0x3c <== NOT EXECUTED 3adac: e1e02000 mvn r2, r0 <== NOT EXECUTED
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
if (blocks)
3adb0: e0922006 adds r2, r2, r6 <== NOT EXECUTED 3adb4: e59dc000 ldr ip, [sp] <== NOT EXECUTED 3adb8: 1a000044 bne 3aed0 <rtems_rfs_file_set_size+0x2ec> <== NOT EXECUTED
blocks =
rtems_rfs_block_map_count (map) -
(((new_size - 1) /
rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle))) + 1);
offset =
3adbc: e1a02007 mov r2, r7 <== NOT EXECUTED 3adc0: e3a03000 mov r3, #0 <== NOT EXECUTED 3adc4: e1a0000a mov r0, sl <== NOT EXECUTED 3adc8: e1a0100b mov r1, fp <== NOT EXECUTED 3adcc: e58dc000 str ip, [sp] <== NOT EXECUTED 3add0: eb008561 bl 5c35c <__umoddi3> <== NOT EXECUTED
*/
static inline void
rtems_rfs_block_map_set_size_offset (rtems_rfs_block_map* map,
rtems_rfs_block_off offset)
{
map->size.offset = offset;
3add4: e5850040 str r0, [r5, #64] ; 0x40 <== NOT EXECUTED
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
3add8: e5942010 ldr r2, [r4, #16] <== NOT EXECUTED
map->dirty = true;
3addc: e3a03001 mov r3, #1 <== NOT EXECUTED 3ade0: e3520000 cmp r2, #0 <== NOT EXECUTED 3ade4: e5c53034 strb r3, [r5, #52] ; 0x34 <== NOT EXECUTED 3ade8: e59dc000 ldr ip, [sp] <== NOT EXECUTED 3adec: 01a03006 moveq r3, r6 <== NOT EXECUTED 3adf0: 1a000025 bne 3ae8c <rtems_rfs_file_set_size+0x2a8> <== NOT EXECUTED 3adf4: e1560002 cmp r6, r2 <== NOT EXECUTED 3adf8: 9a000026 bls 3ae98 <rtems_rfs_file_set_size+0x2b4> <== NOT EXECUTED 3adfc: e2461001 sub r1, r6, #1 <== NOT EXECUTED 3ae00: e1520001 cmp r2, r1 <== NOT EXECUTED 3ae04: 0a000039 beq 3aef0 <rtems_rfs_file_set_size+0x30c> <== NOT EXECUTED
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
3ae08: e5952040 ldr r2, [r5, #64] ; 0x40 <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
3ae0c: e58c3084 str r3, [ip, #132] ; 0x84 <== NOT EXECUTED
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
3ae10: e58c2088 str r2, [ip, #136] ; 0x88 <== NOT EXECUTED
if (rtems_rfs_file_update_mtime (handle))
3ae14: e5944000 ldr r4, [r4] <== NOT EXECUTED 3ae18: e2144002 ands r4, r4, #2 <== NOT EXECUTED 3ae1c: 0a000010 beq 3ae64 <rtems_rfs_file_set_size+0x280> <== NOT EXECUTED
handle->shared->mtime = time (NULL);
3ae20: e3a00000 mov r0, #0 <== NOT EXECUTED
}
return 0;
}
3ae24: e28dd018 add sp, sp, #24 <== NOT EXECUTED
3ae28: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/*
* Short cut for the common truncate on open call.
*/
if (new_size == 0)
{
rc = rtems_rfs_block_map_free_all (rtems_rfs_file_fs (handle), map);
3ae2c: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3ae30: e1a01009 mov r1, r9 <== NOT EXECUTED 3ae34: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3ae38: ebfff836 bl 38f18 <rtems_rfs_block_map_free_all> <== NOT EXECUTED
if (rc > 0)
3ae3c: e3500000 cmp r0, #0 <== NOT EXECUTED 3ae40: cafffff7 bgt 3ae24 <rtems_rfs_file_set_size+0x240> <== NOT EXECUTED
count = new_size - size;
length = rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
read_block = false;
while (count)
3ae44: e594c01c ldr ip, [r4, #28] <== NOT EXECUTED 3ae48: e595303c ldr r3, [r5, #60] ; 0x3c <== NOT EXECUTED
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
3ae4c: e5952040 ldr r2, [r5, #64] ; 0x40 <== NOT EXECUTED
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
rtems_rfs_file_bpos (handle));
}
}
handle->shared->size.count = rtems_rfs_block_map_count (map);
3ae50: e58c3084 str r3, [ip, #132] ; 0x84 <== NOT EXECUTED
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
3ae54: e58c2088 str r2, [ip, #136] ; 0x88 <== NOT EXECUTED
if (rtems_rfs_file_update_mtime (handle))
3ae58: e5944000 ldr r4, [r4] <== NOT EXECUTED 3ae5c: e2144002 ands r4, r4, #2 <== NOT EXECUTED 3ae60: 1affffee bne 3ae20 <rtems_rfs_file_set_size+0x23c> <== NOT EXECUTED
handle->shared->mtime = time (NULL);
3ae64: e1a00004 mov r0, r4 <== NOT EXECUTED 3ae68: e58dc000 str ip, [sp] <== NOT EXECUTED 3ae6c: eb004fd1 bl 4edb8 <time> <== NOT EXECUTED 3ae70: e59dc000 ldr ip, [sp] <== NOT EXECUTED 3ae74: e58c0090 str r0, [ip, #144] ; 0x90 <== NOT EXECUTED 3ae78: e1a00004 mov r0, r4 <== NOT EXECUTED 3ae7c: eaffffe8 b 3ae24 <rtems_rfs_file_set_size+0x240> <== NOT EXECUTED
if (rc > 0)
return rc;
}
else
{
if (size < new_size)
3ae80: e15a0000 cmp sl, r0 <== NOT EXECUTED 3ae84: 9affffbc bls 3ad7c <rtems_rfs_file_set_size+0x198> <== NOT EXECUTED 3ae88: eaffff65 b 3ac24 <rtems_rfs_file_set_size+0x40> <== NOT EXECUTED
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
3ae8c: e3560000 cmp r6, #0 <== NOT EXECUTED 3ae90: e1a03006 mov r3, r6 <== NOT EXECUTED 3ae94: 1affffd6 bne 3adf4 <rtems_rfs_file_set_size+0x210> <== NOT EXECUTED
rtems_rfs_block_map_size (map)))
rtems_rfs_block_size_get_bpos (rtems_rfs_block_map_size (map),
3ae98: e5846010 str r6, [r4, #16] <== NOT EXECUTED 3ae9c: e5953040 ldr r3, [r5, #64] ; 0x40 <== NOT EXECUTED 3aea0: e3530000 cmp r3, #0 <== NOT EXECUTED 3aea4: e3a02000 mov r2, #0 <== NOT EXECUTED 3aea8: 12466001 subne r6, r6, #1 <== NOT EXECUTED 3aeac: e5842018 str r2, [r4, #24] <== NOT EXECUTED 3aeb0: e5843014 str r3, [r4, #20] <== NOT EXECUTED 3aeb4: 15846010 strne r6, [r4, #16] <== NOT EXECUTED 3aeb8: e595303c ldr r3, [r5, #60] ; 0x3c <== NOT EXECUTED 3aebc: eaffffd1 b 3ae08 <rtems_rfs_file_set_size+0x224> <== NOT EXECUTED
/* * If the file is same size do nothing else grow or shrink it ? * * If the file does not change size do not update the times. */ if (size != new_size)
3aec0: e15b0001 cmp fp, r1 <== NOT EXECUTED 3aec4: 1affff51 bne 3ac10 <rtems_rfs_file_set_size+0x2c> <== NOT EXECUTED
handle->shared->size.count = rtems_rfs_block_map_count (map);
handle->shared->size.offset = rtems_rfs_block_map_size_offset (map);
if (rtems_rfs_file_update_mtime (handle))
handle->shared->mtime = time (NULL);
3aec8: e3a00000 mov r0, #0 <== NOT EXECUTED 3aecc: eaffffd4 b 3ae24 <rtems_rfs_file_set_size+0x240> <== NOT EXECUTED
new_size % rtems_rfs_fs_block_size (rtems_rfs_file_fs (handle));
if (blocks)
{
int rc;
rc = rtems_rfs_block_map_shrink (rtems_rfs_file_fs (handle),
3aed0: e1a00009 mov r0, r9 <== NOT EXECUTED 3aed4: e28c1034 add r1, ip, #52 ; 0x34 <== NOT EXECUTED 3aed8: ebfff756 bl 38c38 <rtems_rfs_block_map_shrink> <== NOT EXECUTED
rtems_rfs_file_map (handle),
blocks);
if (rc > 0)
3aedc: e3500000 cmp r0, #0 <== NOT EXECUTED 3aee0: caffffcf bgt 3ae24 <rtems_rfs_file_set_size+0x240> <== NOT EXECUTED 3aee4: e594c01c ldr ip, [r4, #28] <== NOT EXECUTED 3aee8: e595603c ldr r6, [r5, #60] ; 0x3c <== NOT EXECUTED 3aeec: eaffffb2 b 3adbc <rtems_rfs_file_set_size+0x1d8> <== NOT EXECUTED
return rc;
}
rtems_rfs_block_map_set_size_offset (map, offset);
if (rtems_rfs_block_pos_past_end (rtems_rfs_file_bpos (handle),
3aef0: e5942014 ldr r2, [r4, #20] <== NOT EXECUTED 3aef4: e1500002 cmp r0, r2 <== NOT EXECUTED 3aef8: 2affffc2 bcs 3ae08 <rtems_rfs_file_set_size+0x224> <== NOT EXECUTED 3aefc: eaffffe5 b 3ae98 <rtems_rfs_file_set_size+0x2b4> <== NOT EXECUTED
0003bbd8 <rtems_rfs_format>:
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
3bbd8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
3bbdc: e5d13015 ldrb r3, [r1, #21] <== NOT EXECUTED
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
3bbe0: e24dd0e8 sub sp, sp, #232 ; 0xe8 <== NOT EXECUTED
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
3bbe4: e3530000 cmp r3, #0 <== NOT EXECUTED
return rc;
}
int
rtems_rfs_format (const char* name, const rtems_rfs_format_config* config)
{
3bbe8: e1a07001 mov r7, r1 <== NOT EXECUTED 3bbec: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
3bbf0: 1a000098 bne 3be58 <rtems_rfs_format+0x280> <== NOT EXECUTED
printf ("rtems-rfs: format: %s\n", name);
memset (&fs, 0, sizeof (rtems_rfs_file_system));
3bbf4: e28d4014 add r4, sp, #20 <== NOT EXECUTED 3bbf8: e3a01000 mov r1, #0 <== NOT EXECUTED 3bbfc: e3a02080 mov r2, #128 ; 0x80 <== NOT EXECUTED 3bc00: e1a00004 mov r0, r4 <== NOT EXECUTED 3bc04: eb002a30 bl 464cc <memset> <== NOT EXECUTED
the_chain->last = _Chain_Head(the_chain);
3bc08: e2843070 add r3, r4, #112 ; 0x70 <== NOT EXECUTED 3bc0c: e58d308c str r3, [sp, #140] ; 0x8c <== NOT EXECUTED
rtems_chain_initialize_empty (&fs.buffers);
rtems_chain_initialize_empty (&fs.release);
rtems_chain_initialize_empty (&fs.release_modified);
rtems_chain_initialize_empty (&fs.file_shares);
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
3bc10: e3a03005 mov r3, #5 <== NOT EXECUTED 3bc14: e2845050 add r5, r4, #80 ; 0x50 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
3bc18: e284e064 add lr, r4, #100 ; 0x64 <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
3bc1c: e284c060 add ip, r4, #96 ; 0x60 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
3bc20: e2842074 add r2, r4, #116 ; 0x74 <== NOT EXECUTED 3bc24: e58d3050 str r3, [sp, #80] ; 0x50 <== NOT EXECUTED 3bc28: e284a044 add sl, r4, #68 ; 0x44 <== NOT EXECUTED
fs.release_count = 0;
fs.release_modified_count = 0;
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
3bc2c: e3a03002 mov r3, #2 <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
3bc30: e2848040 add r8, r4, #64 ; 0x40 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
3bc34: e2846054 add r6, r4, #84 ; 0x54 <== NOT EXECUTED
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
3bc38: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 3bc3c: e1a01004 mov r1, r4 <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
3bc40: e58d506c str r5, [sp, #108] ; 0x6c <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
3bc44: e58da054 str sl, [sp, #84] ; 0x54 <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
3bc48: e58d805c str r8, [sp, #92] ; 0x5c <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
3bc4c: e58d6064 str r6, [sp, #100] ; 0x64 <== NOT EXECUTED 3bc50: e58de074 str lr, [sp, #116] ; 0x74 <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
3bc54: e58dc07c str ip, [sp, #124] ; 0x7c <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
3bc58: e58d2084 str r2, [sp, #132] ; 0x84 <== NOT EXECUTED
fs.max_held_buffers = RTEMS_RFS_FS_MAX_HELD_BUFFERS;
fs.release_count = 0;
fs.release_modified_count = 0;
fs.flags = RTEMS_RFS_FS_NO_LOCAL_CACHE;
3bc5c: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
3bc60: ebfff71a bl 398d0 <rtems_rfs_buffer_open> <== NOT EXECUTED
if (rc > 0)
3bc64: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3bc68: ca00014b bgt 3c19c <rtems_rfs_format+0x5c4> <== NOT EXECUTED
}
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
3bc6c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 3bc70: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED 3bc74: e3510000 cmp r1, #0 <== NOT EXECUTED 3bc78: 0a000071 beq 3be44 <rtems_rfs_format+0x26c> <== NOT EXECUTED
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
3bc7c: e5975000 ldr r5, [r7] <== NOT EXECUTED
if (!fs->block_size)
3bc80: e3550000 cmp r5, #0 <== NOT EXECUTED
static bool
rtems_rfs_check_config (rtems_rfs_file_system* fs,
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
3bc84: e58d501c str r5, [sp, #28] <== NOT EXECUTED
if (!fs->block_size)
3bc88: 0a00011c beq 3c100 <rtems_rfs_format+0x528> <== NOT EXECUTED
if (fs->block_size > (4 * 1024))
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
3bc8c: e5936024 ldr r6, [r3, #36] ; 0x24 <== NOT EXECUTED 3bc90: e1a00005 mov r0, r5 <== NOT EXECUTED 3bc94: e1a01006 mov r1, r6 <== NOT EXECUTED 3bc98: eb007d26 bl 5b138 <__umodsi3> <== NOT EXECUTED 3bc9c: e3500000 cmp r0, #0 <== NOT EXECUTED 3bca0: 1a000132 bne 3c170 <rtems_rfs_format+0x598> <== NOT EXECUTED
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
3bca4: e5973004 ldr r3, [r7, #4] <== NOT EXECUTED
if (!fs->group_blocks)
3bca8: e3530000 cmp r3, #0 <== NOT EXECUTED
{
/*
* The number of blocks per group is defined by the number of bits in a
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
3bcac: 059d501c ldreq r5, [sp, #28] <== NOT EXECUTED 3bcb0: 159d501c ldrne r5, [sp, #28] <== NOT EXECUTED
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
fs->block_size, rtems_rfs_fs_media_block_size (fs));
return false;
}
fs->group_blocks = config->group_blocks;
3bcb4: e58d3038 str r3, [sp, #56] ; 0x38 <== NOT EXECUTED
{
/*
* The number of blocks per group is defined by the number of bits in a
* block.
*/
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
3bcb8: 01a03185 lsleq r3, r5, #3 <== NOT EXECUTED 3bcbc: 058d3038 streq r3, [sp, #56] ; 0x38 <== NOT EXECUTED
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
3bcc0: e1530185 cmp r3, r5, lsl #3 <== NOT EXECUTED 3bcc4: 8a000109 bhi 3c0f0 <rtems_rfs_format+0x518> <== NOT EXECUTED
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
3bcc8: e1a00004 mov r0, r4 <== NOT EXECUTED 3bccc: ebfffe35 bl 3b5a8 <rtems_rfs_fs_media_size> <== NOT EXECUTED 3bcd0: e59d501c ldr r5, [sp, #28] <== NOT EXECUTED 3bcd4: e3a03000 mov r3, #0 <== NOT EXECUTED 3bcd8: e1a02005 mov r2, r5 <== NOT EXECUTED 3bcdc: eb00808d bl 5bf18 <__udivdi3> <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
3bce0: e3500000 cmp r0, #0 <== NOT EXECUTED
{
printf ("group block count is higher than bits in block\n");
return false;
}
fs->blocks = rtems_rfs_fs_media_size (fs) / fs->block_size;
3bce4: e1a06000 mov r6, r0 <== NOT EXECUTED 3bce8: e58d0018 str r0, [sp, #24] <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
3bcec: 03a01001 moveq r1, #1 <== NOT EXECUTED 3bcf0: 0a000003 beq 3bd04 <rtems_rfs_format+0x12c> <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
3bcf4: e1a01185 lsl r1, r5, #3 <== NOT EXECUTED 3bcf8: e2460001 sub r0, r6, #1 <== NOT EXECUTED 3bcfc: eb007c79 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 3bd00: e2801001 add r1, r0, #1 <== NOT EXECUTED
* per block.
*/
fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
3bd04: e5973008 ldr r3, [r7, #8] <== NOT EXECUTED
if (!fs->group_inodes)
3bd08: e3530000 cmp r3, #0 <== NOT EXECUTED
/* * The bits per block sets the upper limit for the number of blocks in a * group. The disk will be divided into groups which are the number of bits * per block. */ fs->group_count = rtems_rfs_rup_quotient (rtems_rfs_fs_blocks (fs),
3bd0c: e58d1034 str r1, [sp, #52] ; 0x34 <== NOT EXECUTED
rtems_rfs_bits_per_block (fs));
fs->group_inodes = config->group_inodes;
3bd10: e58d303c str r3, [sp, #60] ; 0x3c <== NOT EXECUTED
if (!fs->group_inodes)
3bd14: 1a000011 bne 3bd60 <rtems_rfs_format+0x188> <== NOT EXECUTED
int inode_overhead = RTEMS_RFS_INODE_OVERHEAD_PERCENTAGE;
/*
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
3bd18: e597300c ldr r3, [r7, #12] <== NOT EXECUTED 3bd1c: e3530000 cmp r3, #0 <== NOT EXECUTED 3bd20: 03a03001 moveq r3, #1 <== NOT EXECUTED
static int
rtems_rfs_inodes_from_percent (rtems_rfs_file_system* fs,
int percentage)
{
int blocks;
blocks = ((rtems_rfs_fs_blocks (fs) -
3bd24: e2466001 sub r6, r6, #1 <== NOT EXECUTED 3bd28: e0000396 mul r0, r6, r3 <== NOT EXECUTED 3bd2c: e59f2b4c ldr r2, [pc, #2892] ; 3c880 <rtems_rfs_format+0xca8><== NOT EXECUTED 3bd30: e083c092 umull ip, r3, r2, r0 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
3bd34: e1b032a3 lsrs r3, r3, #5 <== NOT EXECUTED 3bd38: 03a00001 moveq r0, #1 <== NOT EXECUTED 3bd3c: 0a000002 beq 3bd4c <rtems_rfs_format+0x174> <== NOT EXECUTED 3bd40: e2430001 sub r0, r3, #1 <== NOT EXECUTED 3bd44: eb007c67 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 3bd48: e2800001 add r0, r0, #1 <== NOT EXECUTED
* The number of inodes per group is set as a percentage.
*/
if (config->inode_overhead)
inode_overhead = config->inode_overhead;
fs->group_inodes = rtems_rfs_inodes_from_percent (fs, inode_overhead);
3bd4c: e59f3b30 ldr r3, [pc, #2864] ; 3c884 <rtems_rfs_format+0xcac><== NOT EXECUTED 3bd50: e1a011a5 lsr r1, r5, #3 <== NOT EXECUTED 3bd54: e082c193 umull ip, r2, r3, r1 <== NOT EXECUTED 3bd58: e0030092 mul r3, r2, r0 <== NOT EXECUTED 3bd5c: e58d303c str r3, [sp, #60] ; 0x3c <== NOT EXECUTED
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
3bd60: e59f3b1c ldr r3, [pc, #2844] ; 3c884 <rtems_rfs_format+0xcac><== NOT EXECUTED 3bd64: e1a021a5 lsr r2, r5, #3 <== NOT EXECUTED 3bd68: e0861293 umull r1, r6, r3, r2 <== NOT EXECUTED
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
3bd6c: e59d003c ldr r0, [sp, #60] ; 0x3c <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
3bd70: e3500000 cmp r0, #0 <== NOT EXECUTED
}
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
3bd74: e58d6040 str r6, [sp, #64] ; 0x40 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
3bd78: 03a00001 moveq r0, #1 <== NOT EXECUTED 3bd7c: 0a000003 beq 3bd90 <rtems_rfs_format+0x1b8> <== NOT EXECUTED 3bd80: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3bd84: e1a01006 mov r1, r6 <== NOT EXECUTED 3bd88: eb007c56 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 3bd8c: e2800001 add r0, r0, #1 <== NOT EXECUTED
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
fs->group_inodes =
rtems_rfs_rup_quotient (fs->group_inodes,
3bd90: e0030096 mul r3, r6, r0 <== NOT EXECUTED
fs->inodes_per_block) * fs->inodes_per_block;
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
3bd94: e1a02185 lsl r2, r5, #3 <== NOT EXECUTED 3bd98: e1530002 cmp r3, r2 <== NOT EXECUTED
/*
* Round up to fill a block because the minimum allocation unit is a block.
*/
fs->inodes_per_block = rtems_rfs_fs_block_size (fs) / RTEMS_RFS_INODE_SIZE;
fs->group_inodes =
3bd9c: e58d303c str r3, [sp, #60] ; 0x3c <== NOT EXECUTED
rtems_rfs_rup_quotient (fs->group_inodes,
fs->inodes_per_block) * fs->inodes_per_block;
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
3bda0: 858d203c strhi r2, [sp, #60] ; 0x3c <== NOT EXECUTED
fs->max_name_length = config->max_name_length;
3bda4: e5973010 ldr r3, [r7, #16] <== NOT EXECUTED
if (!fs->max_name_length)
3bda8: e3530000 cmp r3, #0 <== NOT EXECUTED
fs->inodes_per_block) * fs->inodes_per_block;
if (fs->group_inodes > rtems_rfs_bitmap_numof_bits (fs->block_size))
fs->group_inodes = rtems_rfs_bitmap_numof_bits (fs->block_size);
fs->max_name_length = config->max_name_length;
3bdac: e58d302c str r3, [sp, #44] ; 0x2c <== NOT EXECUTED
if (!fs->max_name_length)
{
fs->max_name_length = 512;
3bdb0: 03a03c02 moveq r3, #512 ; 0x200 <== NOT EXECUTED 3bdb4: 058d302c streq r3, [sp, #44] ; 0x2c <== NOT EXECUTED
* Check the configuration data.
*/
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
3bdb8: e5d73015 ldrb r3, [r7, #21] <== NOT EXECUTED 3bdbc: e3530000 cmp r3, #0 <== NOT EXECUTED 3bdc0: 1a000091 bne 3c00c <rtems_rfs_format+0x434> <== NOT EXECUTED
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
3bdc4: e1a01005 mov r1, r5 <== NOT EXECUTED 3bdc8: e1a00004 mov r0, r4 <== NOT EXECUTED 3bdcc: ebfff69e bl 3984c <rtems_rfs_buffer_setblksize> <== NOT EXECUTED
if (rc > 0)
3bdd0: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3bdd4: ca0001f6 bgt 3c5b4 <rtems_rfs_format+0x9dc> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
3bdd8: e3a09000 mov r9, #0 <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: handle open failed: %d: %s\n",
rc, strerror (rc));
return false;
}
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, false);
3bddc: e1a00004 mov r0, r4 <== NOT EXECUTED 3bde0: e28d10d4 add r1, sp, #212 ; 0xd4 <== NOT EXECUTED 3bde4: e1a02009 mov r2, r9 <== NOT EXECUTED 3bde8: e1a03009 mov r3, r9 <== NOT EXECUTED 3bdec: e5cd90d4 strb r9, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->bnum = 0;
3bdf0: e58d90d8 str r9, [sp, #216] ; 0xd8 <== NOT EXECUTED
handle->buffer = NULL;
3bdf4: e58d90dc str r9, [sp, #220] ; 0xdc <== NOT EXECUTED 3bdf8: ebfff715 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
3bdfc: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3be00: da000018 ble 3be68 <rtems_rfs_format+0x290> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3be04: e28d10d4 add r1, sp, #212 ; 0xd4 <== NOT EXECUTED 3be08: e1a00004 mov r0, r4 <== NOT EXECUTED 3be0c: ebfff6c6 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
3be10: e1a00005 mov r0, r5 <== NOT EXECUTED
handle->dirty = false; handle->bnum = 0; handle->buffer = NULL;
3be14: e58d90dc str r9, [sp, #220] ; 0xdc <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3be18: e5cd90d4 strb r9, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->bnum = 0;
3be1c: e58d90d8 str r9, [sp, #216] ; 0xd8 <== NOT EXECUTED 3be20: eb0035e3 bl 495b4 <strerror> <== NOT EXECUTED 3be24: e1a01005 mov r1, r5 <== NOT EXECUTED 3be28: e1a02000 mov r2, r0 <== NOT EXECUTED 3be2c: e59f0a54 ldr r0, [pc, #2644] ; 3c888 <rtems_rfs_format+0xcb0><== NOT EXECUTED 3be30: eb002dcc bl 47568 <printf> <== NOT EXECUTED
return -1;
}
if (!rtems_rfs_write_superblock (&fs))
{
printf ("rtems-rfs: format: superblock write failed\n");
3be34: e59f0a50 ldr r0, [pc, #2640] ; 3c88c <rtems_rfs_format+0xcb4><== NOT EXECUTED 3be38: eb002e6f bl 477fc <puts> <== NOT EXECUTED 3be3c: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
3be40: ea000002 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
/*
* Check the media.
*/
if (rtems_rfs_fs_media_block_size (&fs) == 0)
{
printf ("rtems-rfs: media block is invalid: %" PRIu32 "\n",
3be44: e59f0a44 ldr r0, [pc, #2628] ; 3c890 <rtems_rfs_format+0xcb8><== NOT EXECUTED 3be48: eb002dc6 bl 47568 <printf> <== NOT EXECUTED 3be4c: e3e00000 mvn r0, #0 <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
return 0;
}
3be50: e28dd0e8 add sp, sp, #232 ; 0xe8 <== NOT EXECUTED
3be54: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rtems_rfs_file_system fs;
int group;
int rc;
if (config->verbose)
printf ("rtems-rfs: format: %s\n", name);
3be58: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED 3be5c: e59f0a30 ldr r0, [pc, #2608] ; 3c894 <rtems_rfs_format+0xcbc><== NOT EXECUTED 3be60: eb002dc0 bl 47568 <printf> <== NOT EXECUTED 3be64: eaffff62 b 3bbf4 <rtems_rfs_format+0x1c> <== NOT EXECUTED
printf ("rtems-rfs: write-superblock: request failed: %d: %s\n",
rc, strerror (rc));
return false;
}
sb = rtems_rfs_buffer_data (&handle);
3be68: e59d30dc ldr r3, [sp, #220] ; 0xdc <== NOT EXECUTED 3be6c: e5935020 ldr r5, [r3, #32] <== NOT EXECUTED
#define write_sb(_o, _d) rtems_rfs_write_u32(sb + (_o), _d)
memset (sb, 0xff, rtems_rfs_fs_block_size (fs));
3be70: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED 3be74: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 3be78: e1a00005 mov r0, r5 <== NOT EXECUTED 3be7c: eb002992 bl 464cc <memset> <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_MAGIC, RTEMS_RFS_SB_MAGIC);
3be80: e3a03028 mov r3, #40 ; 0x28 <== NOT EXECUTED 3be84: e5c53000 strb r3, [r5] <== NOT EXECUTED 3be88: e3a03009 mov r3, #9 <== NOT EXECUTED 3be8c: e5c53001 strb r3, [r5, #1] <== NOT EXECUTED 3be90: e3a0a001 mov sl, #1 <== NOT EXECUTED 3be94: e3a03020 mov r3, #32 <== NOT EXECUTED 3be98: e5c53002 strb r3, [r5, #2] <== NOT EXECUTED 3be9c: e5c5a003 strb sl, [r5, #3] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_VERSION, RTEMS_RFS_VERSION);
3bea0: e5c59004 strb r9, [r5, #4] <== NOT EXECUTED 3bea4: e5c59005 strb r9, [r5, #5] <== NOT EXECUTED 3bea8: e5c59006 strb r9, [r5, #6] <== NOT EXECUTED 3beac: e5c59007 strb r9, [r5, #7] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_BLOCKS, rtems_rfs_fs_blocks (fs));
3beb0: e5dd301b ldrb r3, [sp, #27] <== NOT EXECUTED 3beb4: e5c5300c strb r3, [r5, #12] <== NOT EXECUTED 3beb8: e1dd31ba ldrh r3, [sp, #26] <== NOT EXECUTED 3bebc: e5c5300d strb r3, [r5, #13] <== NOT EXECUTED 3bec0: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 3bec4: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED 3bec8: e5c5300e strb r3, [r5, #14] <== NOT EXECUTED 3becc: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 3bed0: e5c5300f strb r3, [r5, #15] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs));
3bed4: e5dd301f ldrb r3, [sp, #31] <== NOT EXECUTED 3bed8: e5c53008 strb r3, [r5, #8] <== NOT EXECUTED 3bedc: e1dd31be ldrh r3, [sp, #30] <== NOT EXECUTED 3bee0: e5c53009 strb r3, [r5, #9] <== NOT EXECUTED 3bee4: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 3bee8: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED 3beec: e5c5300a strb r3, [r5, #10] <== NOT EXECUTED 3bef0: e59d301c ldr r3, [sp, #28] <== NOT EXECUTED 3bef4: e5c5300b strb r3, [r5, #11] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks);
3bef8: e5dd302b ldrb r3, [sp, #43] ; 0x2b <== NOT EXECUTED 3befc: e5c53010 strb r3, [r5, #16] <== NOT EXECUTED 3bf00: e1dd32ba ldrh r3, [sp, #42] ; 0x2a <== NOT EXECUTED 3bf04: e5c53011 strb r3, [r5, #17] <== NOT EXECUTED 3bf08: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3bf0c: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED 3bf10: e5c53012 strb r3, [r5, #18] <== NOT EXECUTED 3bf14: e59d3028 ldr r3, [sp, #40] ; 0x28 <== NOT EXECUTED 3bf18: e5c53013 strb r3, [r5, #19] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length);
3bf1c: e5dd302f ldrb r3, [sp, #47] ; 0x2f <== NOT EXECUTED 3bf20: e5c53014 strb r3, [r5, #20] <== NOT EXECUTED 3bf24: e1dd32be ldrh r3, [sp, #46] ; 0x2e <== NOT EXECUTED 3bf28: e5c53015 strb r3, [r5, #21] <== NOT EXECUTED 3bf2c: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED 3bf30: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED 3bf34: e5c53016 strb r3, [r5, #22] <== NOT EXECUTED 3bf38: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED 3bf3c: e5c53017 strb r3, [r5, #23] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count);
3bf40: e5dd3037 ldrb r3, [sp, #55] ; 0x37 <== NOT EXECUTED 3bf44: e5c53018 strb r3, [r5, #24] <== NOT EXECUTED 3bf48: e1dd33b6 ldrh r3, [sp, #54] ; 0x36 <== NOT EXECUTED 3bf4c: e5c53019 strb r3, [r5, #25] <== NOT EXECUTED 3bf50: e59d3034 ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED 3bf54: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED 3bf58: e5c5301a strb r3, [r5, #26] <== NOT EXECUTED 3bf5c: e59d3034 ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED 3bf60: e5c5301b strb r3, [r5, #27] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks);
3bf64: e5dd303b ldrb r3, [sp, #59] ; 0x3b <== NOT EXECUTED 3bf68: e5c5301c strb r3, [r5, #28] <== NOT EXECUTED 3bf6c: e1dd33ba ldrh r3, [sp, #58] ; 0x3a <== NOT EXECUTED 3bf70: e5c5301d strb r3, [r5, #29] <== NOT EXECUTED 3bf74: e59d3038 ldr r3, [sp, #56] ; 0x38 <== NOT EXECUTED 3bf78: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED 3bf7c: e5c5301e strb r3, [r5, #30] <== NOT EXECUTED 3bf80: e59d3038 ldr r3, [sp, #56] ; 0x38 <== NOT EXECUTED 3bf84: e5c5301f strb r3, [r5, #31] <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
3bf88: e5dd303f ldrb r3, [sp, #63] ; 0x3f <== NOT EXECUTED 3bf8c: e5c53020 strb r3, [r5, #32] <== NOT EXECUTED 3bf90: e1dd33be ldrh r3, [sp, #62] ; 0x3e <== NOT EXECUTED 3bf94: e5c53021 strb r3, [r5, #33] ; 0x21 <== NOT EXECUTED 3bf98: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED 3bf9c: e1a03423 lsr r3, r3, #8 <== NOT EXECUTED 3bfa0: e5c53022 strb r3, [r5, #34] ; 0x22 <== NOT EXECUTED 3bfa4: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
3bfa8: e1a00004 mov r0, r4 <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE, rtems_rfs_fs_block_size (fs)); write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks); write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length); write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count); write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks); write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes);
3bfac: e5c53023 strb r3, [r5, #35] ; 0x23 <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
rtems_rfs_buffer_mark_dirty (&handle);
rc = rtems_rfs_buffer_handle_release (fs, &handle);
3bfb0: e28d10d4 add r1, sp, #212 ; 0xd4 <== NOT EXECUTED
write_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS, fs->bad_blocks); write_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH, fs->max_name_length); write_sb (RTEMS_RFS_SB_OFFSET_GROUPS, fs->group_count); write_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS, fs->group_blocks); write_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES, fs->group_inodes); write_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE, RTEMS_RFS_INODE_SIZE);
3bfb4: e3a03038 mov r3, #56 ; 0x38 <== NOT EXECUTED 3bfb8: e5c59024 strb r9, [r5, #36] ; 0x24 <== NOT EXECUTED 3bfbc: e5c59025 strb r9, [r5, #37] ; 0x25 <== NOT EXECUTED 3bfc0: e5c59026 strb r9, [r5, #38] ; 0x26 <== NOT EXECUTED 3bfc4: e5c53027 strb r3, [r5, #39] ; 0x27 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
3bfc8: e5cda0d4 strb sl, [sp, #212] ; 0xd4 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_release (fs, &handle);
3bfcc: ebfff656 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
if (rc > 0)
3bfd0: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3bfd4: da000077 ble 3c1b8 <rtems_rfs_format+0x5e0> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3bfd8: e28d10d4 add r1, sp, #212 ; 0xd4 <== NOT EXECUTED 3bfdc: e1a00004 mov r0, r4 <== NOT EXECUTED 3bfe0: ebfff651 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("rtems-rfs: write-superblock: buffer release failed: %d: %s\n",
3bfe4: e1a00005 mov r0, r5 <== NOT EXECUTED
handle->dirty = false; handle->bnum = 0; handle->buffer = NULL;
3bfe8: e58d90dc str r9, [sp, #220] ; 0xdc <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3bfec: e5cd90d4 strb r9, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->bnum = 0;
3bff0: e58d90d8 str r9, [sp, #216] ; 0xd8 <== NOT EXECUTED 3bff4: eb00356e bl 495b4 <strerror> <== NOT EXECUTED 3bff8: e1a01005 mov r1, r5 <== NOT EXECUTED 3bffc: e1a02000 mov r2, r0 <== NOT EXECUTED 3c000: e59f0890 ldr r0, [pc, #2192] ; 3c898 <rtems_rfs_format+0xcc0><== NOT EXECUTED 3c004: eb002d57 bl 47568 <printf> <== NOT EXECUTED 3c008: eaffff89 b 3be34 <rtems_rfs_format+0x25c> <== NOT EXECUTED
if (!rtems_rfs_check_config (&fs, config))
return -1;
if (config->verbose)
{
printf ("rtems-rfs: format: media size = %" PRIu64 "\n",
3c00c: e1a00004 mov r0, r4 <== NOT EXECUTED 3c010: ebfffd64 bl 3b5a8 <rtems_rfs_fs_media_size> <== NOT EXECUTED 3c014: e1a02001 mov r2, r1 <== NOT EXECUTED 3c018: e1a01000 mov r1, r0 <== NOT EXECUTED 3c01c: e59f0878 ldr r0, [pc, #2168] ; 3c89c <rtems_rfs_format+0xcc4><== NOT EXECUTED 3c020: eb002d50 bl 47568 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_size (&fs));
printf ("rtems-rfs: format: media blocks = %" PRIu32 "\n",
3c024: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 3c028: e59f0870 ldr r0, [pc, #2160] ; 3c8a0 <rtems_rfs_format+0xcc8><== NOT EXECUTED 3c02c: e593101c ldr r1, [r3, #28] <== NOT EXECUTED 3c030: eb002d4c bl 47568 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_blocks (&fs));
printf ("rtems-rfs: format: media block size = %" PRIu32 "\n",
3c034: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 3c038: e59f0864 ldr r0, [pc, #2148] ; 3c8a4 <rtems_rfs_format+0xccc><== NOT EXECUTED 3c03c: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED 3c040: eb002d48 bl 47568 <printf> <== NOT EXECUTED
rtems_rfs_fs_media_block_size (&fs));
printf ("rtems-rfs: format: size = %" PRIu64 "\n",
3c044: e1a00004 mov r0, r4 <== NOT EXECUTED 3c048: ebfffd4e bl 3b588 <rtems_rfs_fs_size> <== NOT EXECUTED 3c04c: e1a02001 mov r2, r1 <== NOT EXECUTED 3c050: e1a01000 mov r1, r0 <== NOT EXECUTED 3c054: e59f084c ldr r0, [pc, #2124] ; 3c8a8 <rtems_rfs_format+0xcd0><== NOT EXECUTED 3c058: eb002d42 bl 47568 <printf> <== NOT EXECUTED
rtems_rfs_fs_size (&fs));
printf ("rtems-rfs: format: blocks = %zu\n",
3c05c: e59d1018 ldr r1, [sp, #24] <== NOT EXECUTED 3c060: e59f0844 ldr r0, [pc, #2116] ; 3c8ac <rtems_rfs_format+0xcd4><== NOT EXECUTED 3c064: eb002d3f bl 47568 <printf> <== NOT EXECUTED
rtems_rfs_fs_blocks (&fs));
printf ("rtems-rfs: format: block size = %zu\n",
3c068: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 3c06c: e59f083c ldr r0, [pc, #2108] ; 3c8b0 <rtems_rfs_format+0xcd8><== NOT EXECUTED 3c070: eb002d3c bl 47568 <printf> <== NOT EXECUTED
rtems_rfs_fs_block_size (&fs));
printf ("rtems-rfs: format: bits per block = %u\n",
3c074: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 3c078: e59f0834 ldr r0, [pc, #2100] ; 3c8b4 <rtems_rfs_format+0xcdc><== NOT EXECUTED 3c07c: e1a01181 lsl r1, r1, #3 <== NOT EXECUTED 3c080: eb002d38 bl 47568 <printf> <== NOT EXECUTED
rtems_rfs_bits_per_block (&fs));
printf ("rtems-rfs: format: inode size = %zu\n", RTEMS_RFS_INODE_SIZE);
3c084: e3a01038 mov r1, #56 ; 0x38 <== NOT EXECUTED 3c088: e59f0828 ldr r0, [pc, #2088] ; 3c8b8 <rtems_rfs_format+0xce0><== NOT EXECUTED 3c08c: eb002d35 bl 47568 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: inodes = %zu (%d.%d%%)\n",
3c090: e1a00004 mov r0, r4 <== NOT EXECUTED 3c094: ebfffeb0 bl 3bb5c <rtems_rfs_inode_overhead> <== NOT EXECUTED 3c098: e59f381c ldr r3, [pc, #2076] ; 3c8bc <rtems_rfs_format+0xce4><== NOT EXECUTED 3c09c: e0c2c093 smull ip, r2, r3, r0 <== NOT EXECUTED 3c0a0: e1a03fc0 asr r3, r0, #31 <== NOT EXECUTED 3c0a4: e0632142 rsb r2, r3, r2, asr #2 <== NOT EXECUTED 3c0a8: e0823102 add r3, r2, r2, lsl #2 <== NOT EXECUTED 3c0ac: e0403083 sub r3, r0, r3, lsl #1 <== NOT EXECUTED 3c0b0: e59d1034 ldr r1, [sp, #52] ; 0x34 <== NOT EXECUTED 3c0b4: e59d003c ldr r0, [sp, #60] ; 0x3c <== NOT EXECUTED 3c0b8: e0010190 mul r1, r0, r1 <== NOT EXECUTED 3c0bc: e59f07fc ldr r0, [pc, #2044] ; 3c8c0 <rtems_rfs_format+0xce8><== NOT EXECUTED 3c0c0: eb002d28 bl 47568 <printf> <== NOT EXECUTED
fs.group_inodes * fs.group_count,
rtems_rfs_inode_overhead (&fs) / 10,
rtems_rfs_inode_overhead (&fs) % 10);
printf ("rtems-rfs: format: groups = %u\n", fs.group_count);
3c0c4: e59d1034 ldr r1, [sp, #52] ; 0x34 <== NOT EXECUTED 3c0c8: e59f07f4 ldr r0, [pc, #2036] ; 3c8c4 <rtems_rfs_format+0xcec><== NOT EXECUTED 3c0cc: eb002d25 bl 47568 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group blocks = %zu\n", fs.group_blocks);
3c0d0: e59d1038 ldr r1, [sp, #56] ; 0x38 <== NOT EXECUTED 3c0d4: e59f07ec ldr r0, [pc, #2028] ; 3c8c8 <rtems_rfs_format+0xcf0><== NOT EXECUTED 3c0d8: eb002d22 bl 47568 <printf> <== NOT EXECUTED
printf ("rtems-rfs: format: group inodes = %zu\n", fs.group_inodes);
3c0dc: e59f07e8 ldr r0, [pc, #2024] ; 3c8cc <rtems_rfs_format+0xcf4><== NOT EXECUTED 3c0e0: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED 3c0e4: eb002d1f bl 47568 <printf> <== NOT EXECUTED 3c0e8: e59d501c ldr r5, [sp, #28] <== NOT EXECUTED 3c0ec: eaffff34 b 3bdc4 <rtems_rfs_format+0x1ec> <== NOT EXECUTED
fs->group_blocks = rtems_rfs_bitmap_numof_bits (fs->block_size);
}
if (fs->group_blocks > rtems_rfs_bitmap_numof_bits (fs->block_size))
{
printf ("group block count is higher than bits in block\n");
3c0f0: e59f07d8 ldr r0, [pc, #2008] ; 3c8d0 <rtems_rfs_format+0xcf8><== NOT EXECUTED 3c0f4: eb002dc0 bl 477fc <puts> <== NOT EXECUTED 3c0f8: e3e00000 mvn r0, #0 <== NOT EXECUTED 3c0fc: eaffff53 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
const rtems_rfs_format_config* config)
{
fs->block_size = config->block_size;
if (!fs->block_size)
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
3c100: e1a00004 mov r0, r4 <== NOT EXECUTED 3c104: ebfffd27 bl 3b5a8 <rtems_rfs_fs_media_size> <== NOT EXECUTED
if (total_size >= GIGS (1))
3c108: e3510000 cmp r1, #0 <== NOT EXECUTED 3c10c: 1a000002 bne 3c11c <rtems_rfs_format+0x544> <== NOT EXECUTED 3c110: e3500601 cmp r0, #1048576 ; 0x100000 <== NOT EXECUTED 3c114: 359d501c ldrcc r5, [sp, #28] <== NOT EXECUTED 3c118: 3a00000e bcc 3c158 <rtems_rfs_format+0x580> <== NOT EXECUTED
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
3c11c: e3a02601 mov r2, #1048576 ; 0x100000 <== NOT EXECUTED 3c120: e0922000 adds r2, r2, r0 <== NOT EXECUTED 3c124: e3a03000 mov r3, #0 <== NOT EXECUTED 3c128: e0a33001 adc r3, r3, r1 <== NOT EXECUTED 3c12c: e1a01a22 lsr r1, r2, #20 <== NOT EXECUTED 3c130: e1811603 orr r1, r1, r3, lsl #12 <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
if ((gigs & (1 << b)) != 0)
3c134: e3a02001 mov r2, #1 <== NOT EXECUTED
{
uint64_t total_size = rtems_rfs_fs_media_size (fs);
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
3c138: e3a0301f mov r3, #31 <== NOT EXECUTED 3c13c: ea000001 b 3c148 <rtems_rfs_format+0x570> <== NOT EXECUTED
int b;
for (b = 31; b > 0; b--)
3c140: e2533001 subs r3, r3, #1 <== NOT EXECUTED 3c144: 0a000121 beq 3c5d0 <rtems_rfs_format+0x9f8> <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
3c148: e1a05312 lsl r5, r2, r3 <== NOT EXECUTED 3c14c: e1150001 tst r5, r1 <== NOT EXECUTED 3c150: 0afffffa beq 3c140 <rtems_rfs_format+0x568> <== NOT EXECUTED
break;
fs->block_size = 1 << b;
3c154: e58d501c str r5, [sp, #28] <== NOT EXECUTED
}
if (fs->block_size < 512)
3c158: e3550c02 cmp r5, #512 ; 0x200 <== NOT EXECUTED 3c15c: 2a000009 bcs 3c188 <rtems_rfs_format+0x5b0> <== NOT EXECUTED
fs->block_size = 512;
3c160: e3a05c02 mov r5, #512 ; 0x200 <== NOT EXECUTED 3c164: e58d501c str r5, [sp, #28] <== NOT EXECUTED 3c168: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 3c16c: eafffec6 b 3bc8c <rtems_rfs_format+0xb4> <== NOT EXECUTED
fs->block_size = (4 * 1024);
}
if ((fs->block_size % rtems_rfs_fs_media_block_size (fs)) != 0)
{
printf ("block size (%zd) is not a multiple of media block size (%" PRId32 ")\n",
3c170: e1a01005 mov r1, r5 <== NOT EXECUTED 3c174: e1a02006 mov r2, r6 <== NOT EXECUTED 3c178: e59f0754 ldr r0, [pc, #1876] ; 3c8d4 <rtems_rfs_format+0xcfc><== NOT EXECUTED 3c17c: eb002cf9 bl 47568 <printf> <== NOT EXECUTED 3c180: e3e00000 mvn r0, #0 <== NOT EXECUTED 3c184: eaffff31 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
}
if (fs->block_size < 512)
fs->block_size = 512;
if (fs->block_size > (4 * 1024))
3c188: e3550a01 cmp r5, #4096 ; 0x1000 <== NOT EXECUTED
fs->block_size = (4 * 1024);
3c18c: 83a05a01 movhi r5, #4096 ; 0x1000 <== NOT EXECUTED 3c190: 858d501c strhi r5, [sp, #28] <== NOT EXECUTED 3c194: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 3c198: eafffebb b 3bc8c <rtems_rfs_format+0xb4> <== NOT EXECUTED
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, &fs);
if (rc > 0)
{
printf ("rtems-rfs: format: buffer open failed: %d: %s\n",
3c19c: eb003504 bl 495b4 <strerror> <== NOT EXECUTED 3c1a0: e1a01005 mov r1, r5 <== NOT EXECUTED 3c1a4: e1a02000 mov r2, r0 <== NOT EXECUTED 3c1a8: e59f0728 ldr r0, [pc, #1832] ; 3c8d8 <rtems_rfs_format+0xd00><== NOT EXECUTED 3c1ac: eb002ced bl 47568 <printf> <== NOT EXECUTED 3c1b0: e3e00000 mvn r0, #0 <== NOT EXECUTED
rc, strerror (rc));
return -1;
3c1b4: eaffff25 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3c1b8: e1a00004 mov r0, r4 <== NOT EXECUTED 3c1bc: e28d10d4 add r1, sp, #212 ; 0xd4 <== NOT EXECUTED 3c1c0: ebfff5d9 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
3c1c4: e59d3034 ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED 3c1c8: e3530000 cmp r3, #0 <== NOT EXECUTED
handle->dirty = false;
3c1cc: e5cd90d4 strb r9, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->bnum = 0;
3c1d0: e58d90d8 str r9, [sp, #216] ; 0xd8 <== NOT EXECUTED
handle->buffer = NULL;
3c1d4: e58d90dc str r9, [sp, #220] ; 0xdc <== NOT EXECUTED 3c1d8: da00009d ble 3c454 <rtems_rfs_format+0x87c> <== NOT EXECUTED
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
3c1dc: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
3c1e0: e5d72014 ldrb r2, [r7, #20] <== NOT EXECUTED
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
3c1e4: e3530000 cmp r3, #0 <== NOT EXECUTED
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
3c1e8: e58d2004 str r2, [sp, #4] <== NOT EXECUTED 3c1ec: e5d78015 ldrb r8, [r7, #21] <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
3c1f0: e59d6038 ldr r6, [sp, #56] ; 0x38 <== NOT EXECUTED
if (group_base > rtems_rfs_fs_blocks (fs))
3c1f4: 01a09003 moveq r9, r3 <== NOT EXECUTED 3c1f8: 0a000056 beq 3c358 <rtems_rfs_format+0x780> <== NOT EXECUTED
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
3c1fc: e1a0500a mov r5, sl <== NOT EXECUTED 3c200: e28da0bc add sl, sp, #188 ; 0xbc <== NOT EXECUTED
/* * Be nice to strange sizes of disks. These are embedded systems after all * and nice numbers do not always work out. Let the last block pick up the * remainder of the blocks. */ if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
3c204: e0862005 add r2, r6, r5 <== NOT EXECUTED 3c208: e1530002 cmp r3, r2 <== NOT EXECUTED
group_size = rtems_rfs_fs_blocks (fs) - group_base;
3c20c: 30656003 rsbcc r6, r5, r3 <== NOT EXECUTED
if (verbose)
3c210: e3580000 cmp r8, #0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
3c214: 05cd80d4 strbeq r8, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->bnum = 0;
3c218: 058d80d8 streq r8, [sp, #216] ; 0xd8 <== NOT EXECUTED
handle->buffer = NULL;
3c21c: 058d80dc streq r8, [sp, #220] ; 0xdc <== NOT EXECUTED 3c220: 1a000032 bne 3c2f0 <rtems_rfs_format+0x718> <== NOT EXECUTED
printf (", blocks");
/*
* Open the block bitmap using the new buffer.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
3c224: e1a0000a mov r0, sl <== NOT EXECUTED 3c228: e1a01004 mov r1, r4 <== NOT EXECUTED 3c22c: e28d20d4 add r2, sp, #212 ; 0xd4 <== NOT EXECUTED 3c230: e1a03006 mov r3, r6 <== NOT EXECUTED 3c234: e58d5000 str r5, [sp] <== NOT EXECUTED 3c238: eb001852 bl 42388 <rtems_rfs_bitmap_open> <== NOT EXECUTED
group_base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
3c23c: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3c240: da00000f ble 3c284 <rtems_rfs_format+0x6ac> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3c244: e28d10d4 add r1, sp, #212 ; 0xd4 <== NOT EXECUTED 3c248: e1a00004 mov r0, r4 <== NOT EXECUTED 3c24c: ebfff5b6 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
3c250: e3a03000 mov r3, #0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: open block bitmap failed: %d: %s\n",
3c254: e1a0000b mov r0, fp <== NOT EXECUTED
handle->bnum = 0; handle->buffer = NULL;
3c258: e58d30dc str r3, [sp, #220] ; 0xdc <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3c25c: e5cd30d4 strb r3, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->bnum = 0;
3c260: e58d30d8 str r3, [sp, #216] ; 0xd8 <== NOT EXECUTED 3c264: eb0034d2 bl 495b4 <strerror> <== NOT EXECUTED 3c268: e1a01009 mov r1, r9 <== NOT EXECUTED 3c26c: e1a03000 mov r3, r0 <== NOT EXECUTED 3c270: e1a0200b mov r2, fp <== NOT EXECUTED 3c274: e59f0660 ldr r0, [pc, #1632] ; 3c8dc <rtems_rfs_format+0xd04><== NOT EXECUTED 3c278: eb002cba bl 47568 <printf> <== NOT EXECUTED 3c27c: e3e00000 mvn r0, #0 <== NOT EXECUTED 3c280: eafffef2 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
3c284: e59d30dc ldr r3, [sp, #220] ; 0xdc <== NOT EXECUTED 3c288: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED 3c28c: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 3c290: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 3c294: eb00288c bl 464cc <memset> <== NOT EXECUTED
/*
* Clear the bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
3c298: e1a0000a mov r0, sl <== NOT EXECUTED 3c29c: eb00184b bl 423d0 <rtems_rfs_bitmap_map_clear_all> <== NOT EXECUTED
if (rc > 0)
3c2a0: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3c2a4: da000030 ble 3c36c <rtems_rfs_format+0x794> <== NOT EXECUTED
{
rtems_rfs_bitmap_close (&bitmap);
3c2a8: e1a0000a mov r0, sl <== NOT EXECUTED 3c2ac: eb0017eb bl 42260 <rtems_rfs_bitmap_close> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3c2b0: e28d10d4 add r1, sp, #212 ; 0xd4 <== NOT EXECUTED 3c2b4: e1a00004 mov r0, r4 <== NOT EXECUTED 3c2b8: ebfff59b bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
3c2bc: e3a03000 mov r3, #0 <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
printf ("\nrtems-rfs: write-group: group %3d: block bitmap clear all failed: %d: %s\n",
3c2c0: e1a0000b mov r0, fp <== NOT EXECUTED
handle->bnum = 0; handle->buffer = NULL;
3c2c4: e58d30dc str r3, [sp, #220] ; 0xdc <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3c2c8: e5cd30d4 strb r3, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->bnum = 0;
3c2cc: e58d30d8 str r3, [sp, #216] ; 0xd8 <== NOT EXECUTED 3c2d0: eb0034b7 bl 495b4 <strerror> <== NOT EXECUTED 3c2d4: e1a01009 mov r1, r9 <== NOT EXECUTED 3c2d8: e1a03000 mov r3, r0 <== NOT EXECUTED 3c2dc: e1a0200b mov r2, fp <== NOT EXECUTED 3c2e0: e59f05f8 ldr r0, [pc, #1528] ; 3c8e0 <rtems_rfs_format+0xd08><== NOT EXECUTED 3c2e4: eb002c9f bl 47568 <printf> <== NOT EXECUTED 3c2e8: e3e00000 mvn r0, #0 <== NOT EXECUTED 3c2ec: eafffed7 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
*/
if ((group_base + group_size) > rtems_rfs_fs_blocks (fs))
group_size = rtems_rfs_fs_blocks (fs) - group_base;
if (verbose)
printf ("\rrtems-rfs: format: group %3d: base = %" PRId32 ", size = %zd",
3c2f0: e1a02005 mov r2, r5 <== NOT EXECUTED 3c2f4: e1a03006 mov r3, r6 <== NOT EXECUTED 3c2f8: e1a01009 mov r1, r9 <== NOT EXECUTED 3c2fc: e59f05e0 ldr r0, [pc, #1504] ; 3c8e4 <rtems_rfs_format+0xd0c><== NOT EXECUTED 3c300: eb002c98 bl 47568 <printf> <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
3c304: e3a03000 mov r3, #0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
3c308: e3a02000 mov r2, #0 <== NOT EXECUTED
rc, strerror (rc));
return false;
}
if (verbose)
printf (", blocks");
3c30c: e59f05d4 ldr r0, [pc, #1492] ; 3c8e8 <rtems_rfs_format+0xd10><== NOT EXECUTED 3c310: e5cd20d4 strb r2, [sp, #212] ; 0xd4 <== NOT EXECUTED
handle->bnum = 0;
3c314: e58d30d8 str r3, [sp, #216] ; 0xd8 <== NOT EXECUTED
handle->buffer = NULL;
3c318: e58d30dc str r3, [sp, #220] ; 0xdc <== NOT EXECUTED 3c31c: eb002c91 bl 47568 <printf> <== NOT EXECUTED 3c320: eaffffbf b 3c224 <rtems_rfs_format+0x64c> <== NOT EXECUTED
{
printf ("rtems-rfs: format: superblock write failed\n");
return -1;
}
for (group = 0; group < fs.group_count; group++)
3c324: e59d3034 ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED 3c328: e2899001 add r9, r9, #1 <== NOT EXECUTED 3c32c: e1530009 cmp r3, r9 <== NOT EXECUTED 3c330: da000047 ble 3c454 <rtems_rfs_format+0x87c> <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
3c334: e59d6038 ldr r6, [sp, #56] ; 0x38 <== NOT EXECUTED 3c338: e0050996 mul r5, r6, r9 <== NOT EXECUTED
if (group_base > rtems_rfs_fs_blocks (fs))
3c33c: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
size_t group_size;
int blocks;
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
3c340: e2855001 add r5, r5, #1 <== NOT EXECUTED
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
3c344: e5d71014 ldrb r1, [r7, #20] <== NOT EXECUTED
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
3c348: e1550003 cmp r5, r3 <== NOT EXECUTED
return -1;
}
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
3c34c: e58d1004 str r1, [sp, #4] <== NOT EXECUTED 3c350: e5d78015 ldrb r8, [r7, #21] <== NOT EXECUTED
int b;
int rc;
group_base = rtems_rfs_fs_block (fs, group, 0);
if (group_base > rtems_rfs_fs_blocks (fs))
3c354: 9affffaa bls 3c204 <rtems_rfs_format+0x62c> <== NOT EXECUTED
{
printf ("rtems-rfs: write-group: group %d base beyond disk limit\n",
3c358: e1a01009 mov r1, r9 <== NOT EXECUTED 3c35c: e59f0588 ldr r0, [pc, #1416] ; 3c8ec <rtems_rfs_format+0xd14><== NOT EXECUTED 3c360: eb002c80 bl 47568 <printf> <== NOT EXECUTED 3c364: e3e00000 mvn r0, #0 <== NOT EXECUTED 3c368: eafffeb8 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
}
/*
* Forced allocation of the block bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
3c36c: e3a01000 mov r1, #0 <== NOT EXECUTED 3c370: e1a0000a mov r0, sl <== NOT EXECUTED 3c374: eb0018a3 bl 42608 <rtems_rfs_bitmap_map_set> <== NOT EXECUTED
/*
* Forced allocation of the inode bitmap.
*/
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
3c378: e3a01001 mov r1, #1 <== NOT EXECUTED 3c37c: e1a0000a mov r0, sl <== NOT EXECUTED 3c380: eb0018a0 bl 42608 <rtems_rfs_bitmap_map_set> <== NOT EXECUTED
/*
* Determine the number of inodes blocks in the group.
*/
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
3c384: e59d003c ldr r0, [sp, #60] ; 0x3c <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
3c388: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_rfs_bitmap_map_set (&bitmap, RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
/*
* Determine the number of inodes blocks in the group.
*/
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
3c38c: e59d1040 ldr r1, [sp, #64] ; 0x40 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
3c390: 1a000028 bne 3c438 <rtems_rfs_format+0x860> <== NOT EXECUTED 3c394: e3a0c001 mov ip, #1 <== NOT EXECUTED 3c398: e58dc00c str ip, [sp, #12] <== NOT EXECUTED 3c39c: e58d8010 str r8, [sp, #16] <== NOT EXECUTED 3c3a0: e59d800c ldr r8, [sp, #12] <== NOT EXECUTED 3c3a4: e3a0b000 mov fp, #0 <== NOT EXECUTED
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
3c3a8: e28b1002 add r1, fp, #2 <== NOT EXECUTED 3c3ac: e1a0000a mov r0, sl <== NOT EXECUTED
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
3c3b0: e28bb001 add fp, fp, #1 <== NOT EXECUTED
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
3c3b4: eb001893 bl 42608 <rtems_rfs_bitmap_map_set> <== NOT EXECUTED
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
3c3b8: e15b0008 cmp fp, r8 <== NOT EXECUTED 3c3bc: bafffff9 blt 3c3a8 <rtems_rfs_format+0x7d0> <== NOT EXECUTED 3c3c0: e59d8010 ldr r8, [sp, #16] <== NOT EXECUTED
rtems_rfs_bitmap_map_set (&bitmap, b + RTEMS_RFS_GROUP_INODE_BLOCK);
/*
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
3c3c4: e1a0000a mov r0, sl <== NOT EXECUTED 3c3c8: eb0017a4 bl 42260 <rtems_rfs_bitmap_close> <== NOT EXECUTED
if (rc > 0)
3c3cc: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3c3d0: ca00003f bgt 3c4d4 <rtems_rfs_format+0x8fc> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
3c3d4: e3a01001 mov r1, #1 <== NOT EXECUTED
if (verbose)
3c3d8: e3580000 cmp r8, #0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
3c3dc: e5cd10d4 strb r1, [sp, #212] ; 0xd4 <== NOT EXECUTED
if (verbose)
3c3e0: 1a00005e bne 3c560 <rtems_rfs_format+0x988> <== NOT EXECUTED
printf (", inodes");
/*
* Open the inode bitmap using the old buffer. Should release any changes.
*/
rc = rtems_rfs_bitmap_open (&bitmap, fs, &handle, group_size,
3c3e4: e1a03006 mov r3, r6 <== NOT EXECUTED 3c3e8: e285c001 add ip, r5, #1 <== NOT EXECUTED 3c3ec: e1a0000a mov r0, sl <== NOT EXECUTED 3c3f0: e1a01004 mov r1, r4 <== NOT EXECUTED 3c3f4: e28d20d4 add r2, sp, #212 ; 0xd4 <== NOT EXECUTED 3c3f8: e58dc000 str ip, [sp] <== NOT EXECUTED 3c3fc: eb0017e1 bl 42388 <rtems_rfs_bitmap_open> <== NOT EXECUTED
group_base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
3c400: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3c404: da00003e ble 3c504 <rtems_rfs_format+0x92c> <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
3c408: e28d10d4 add r1, sp, #212 ; 0xd4 <== NOT EXECUTED 3c40c: e1a00004 mov r0, r4 <== NOT EXECUTED 3c410: ebfffde8 bl 3bbb8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: open inode bitmap failed: %d: %s\n",
3c414: e1a00006 mov r0, r6 <== NOT EXECUTED 3c418: eb003465 bl 495b4 <strerror> <== NOT EXECUTED 3c41c: e1a01009 mov r1, r9 <== NOT EXECUTED 3c420: e1a03000 mov r3, r0 <== NOT EXECUTED 3c424: e1a02006 mov r2, r6 <== NOT EXECUTED 3c428: e59f04c0 ldr r0, [pc, #1216] ; 3c8f0 <rtems_rfs_format+0xd18><== NOT EXECUTED 3c42c: eb002c4d bl 47568 <printf> <== NOT EXECUTED 3c430: e3e00000 mvn r0, #0 <== NOT EXECUTED 3c434: eafffe85 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
3c438: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3c43c: eb007aa9 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 3c440: e2800001 add r0, r0, #1 <== NOT EXECUTED
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
3c444: e3500000 cmp r0, #0 <== NOT EXECUTED
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
return 1;
return ((dividend - 1) / divisor) + 1;
3c448: e58d000c str r0, [sp, #12] <== NOT EXECUTED
blocks = rtems_rfs_rup_quotient (fs->group_inodes, fs->inodes_per_block);
/*
* Forced allocation of the inode blocks which follow the block bitmap.
*/
for (b = 0; b < blocks; b++)
3c44c: caffffd2 bgt 3c39c <rtems_rfs_format+0x7c4> <== NOT EXECUTED 3c450: eaffffdb b 3c3c4 <rtems_rfs_format+0x7ec> <== NOT EXECUTED
for (group = 0; group < fs.group_count; group++)
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
3c454: e5d73015 ldrb r3, [r7, #21] <== NOT EXECUTED 3c458: e3530000 cmp r3, #0 <== NOT EXECUTED 3c45c: 1a000051 bne 3c5a8 <rtems_rfs_format+0x9d0> <== NOT EXECUTED
printf ("\n");
rc = rtems_rfs_buffer_close (&fs);
3c460: e1a00004 mov r0, r4 <== NOT EXECUTED 3c464: ebfff50f bl 398a8 <rtems_rfs_buffer_close> <== NOT EXECUTED
if (rc > 0)
3c468: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3c46c: ca00009f bgt 3c6f0 <rtems_rfs_format+0xb18> <== NOT EXECUTED
int rc;
/*
* External API so returns -1.
*/
rc = rtems_rfs_fs_open (name, NULL,
3c470: e3a01000 mov r1, #0 <== NOT EXECUTED 3c474: e28dc0e4 add ip, sp, #228 ; 0xe4 <== NOT EXECUTED 3c478: e59d0008 ldr r0, [sp, #8] <== NOT EXECUTED 3c47c: e3a02006 mov r2, #6 <== NOT EXECUTED 3c480: e1a03001 mov r3, r1 <== NOT EXECUTED 3c484: e58dc000 str ip, [sp] <== NOT EXECUTED 3c488: ebfffc6d bl 3b644 <rtems_rfs_fs_open> <== NOT EXECUTED
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
3c48c: e3500000 cmp r0, #0 <== NOT EXECUTED 3c490: ba0000e4 blt 3c828 <rtems_rfs_format+0xc50> <== NOT EXECUTED
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
errno, strerror (errno));
return -1;
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
3c494: e59d00e4 ldr r0, [sp, #228] ; 0xe4 <== NOT EXECUTED 3c498: e3a01001 mov r1, #1 <== NOT EXECUTED 3c49c: e28d20e0 add r2, sp, #224 ; 0xe0 <== NOT EXECUTED 3c4a0: eb0003c9 bl 3d3cc <rtems_rfs_inode_alloc> <== NOT EXECUTED
if (rc > 0)
3c4a4: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3c4a8: ca00002f bgt 3c56c <rtems_rfs_format+0x994> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
return rc;
}
if (ino != RTEMS_RFS_ROOT_INO)
3c4ac: e59d40e0 ldr r4, [sp, #224] ; 0xe0 <== NOT EXECUTED 3c4b0: e3540001 cmp r4, #1 <== NOT EXECUTED 3c4b4: 0a000048 beq 3c5dc <rtems_rfs_format+0xa04> <== NOT EXECUTED
{
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
3c4b8: e1a01004 mov r1, r4 <== NOT EXECUTED 3c4bc: e59f0430 ldr r0, [pc, #1072] ; 3c8f4 <rtems_rfs_format+0xd1c><== NOT EXECUTED 3c4c0: eb002c28 bl 47568 <printf> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
3c4c4: e59d00e4 ldr r0, [sp, #228] ; 0xe4 <== NOT EXECUTED 3c4c8: ebfffc3f bl 3b5cc <rtems_rfs_fs_close> <== NOT EXECUTED 3c4cc: e3a00000 mov r0, #0 <== NOT EXECUTED 3c4d0: eafffe5e b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
* Close the block bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
3c4d4: e28d10d4 add r1, sp, #212 ; 0xd4 <== NOT EXECUTED 3c4d8: e1a00004 mov r0, r4 <== NOT EXECUTED 3c4dc: ebfffdb5 bl 3bbb8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close block bitmap failed: %d: %s\n",
3c4e0: e1a0000b mov r0, fp <== NOT EXECUTED 3c4e4: eb003432 bl 495b4 <strerror> <== NOT EXECUTED 3c4e8: e1a01009 mov r1, r9 <== NOT EXECUTED 3c4ec: e1a03000 mov r3, r0 <== NOT EXECUTED 3c4f0: e1a0200b mov r2, fp <== NOT EXECUTED 3c4f4: e59f03fc ldr r0, [pc, #1020] ; 3c8f8 <rtems_rfs_format+0xd20><== NOT EXECUTED 3c4f8: eb002c1a bl 47568 <printf> <== NOT EXECUTED 3c4fc: e3e00000 mvn r0, #0 <== NOT EXECUTED 3c500: eafffe52 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0x00, rtems_rfs_fs_block_size (fs));
3c504: e59d30dc ldr r3, [sp, #220] ; 0xdc <== NOT EXECUTED 3c508: e3a01000 mov r1, #0 <== NOT EXECUTED 3c50c: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 3c510: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 3c514: eb0027ec bl 464cc <memset> <== NOT EXECUTED
/*
* Clear the inode bitmap.
*/
rc = rtems_rfs_bitmap_map_clear_all (&bitmap);
3c518: e1a0000a mov r0, sl <== NOT EXECUTED 3c51c: eb0017ab bl 423d0 <rtems_rfs_bitmap_map_clear_all> <== NOT EXECUTED
if (rc > 0)
3c520: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3c524: da000040 ble 3c62c <rtems_rfs_format+0xa54> <== NOT EXECUTED
{
rtems_rfs_bitmap_close (&bitmap);
3c528: e1a0000a mov r0, sl <== NOT EXECUTED 3c52c: eb00174b bl 42260 <rtems_rfs_bitmap_close> <== NOT EXECUTED
rtems_rfs_buffer_handle_close (fs, &handle);
3c530: e28d10d4 add r1, sp, #212 ; 0xd4 <== NOT EXECUTED 3c534: e1a00004 mov r0, r4 <== NOT EXECUTED 3c538: ebfffd9e bl 3bbb8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: inode bitmap" \
3c53c: e1a00006 mov r0, r6 <== NOT EXECUTED 3c540: eb00341b bl 495b4 <strerror> <== NOT EXECUTED 3c544: e1a01009 mov r1, r9 <== NOT EXECUTED 3c548: e1a03000 mov r3, r0 <== NOT EXECUTED 3c54c: e1a02006 mov r2, r6 <== NOT EXECUTED 3c550: e59f03a4 ldr r0, [pc, #932] ; 3c8fc <rtems_rfs_format+0xd24><== NOT EXECUTED 3c554: eb002c03 bl 47568 <printf> <== NOT EXECUTED 3c558: e3e00000 mvn r0, #0 <== NOT EXECUTED 3c55c: eafffe3b b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
}
rtems_rfs_buffer_mark_dirty (&handle);
if (verbose)
printf (", inodes");
3c560: e59f0398 ldr r0, [pc, #920] ; 3c900 <rtems_rfs_format+0xd28><== NOT EXECUTED 3c564: eb002bff bl 47568 <printf> <== NOT EXECUTED 3c568: eaffff9d b 3c3e4 <rtems_rfs_format+0x80c> <== NOT EXECUTED
}
rc = rtems_rfs_inode_alloc (fs, RTEMS_RFS_ROOT_INO, &ino);
if (rc > 0)
{
printf ("rtems-rfs: format: inode allocation failed: %d: %s\n",
3c56c: eb003410 bl 495b4 <strerror> <== NOT EXECUTED 3c570: e1a01006 mov r1, r6 <== NOT EXECUTED 3c574: e1a02000 mov r2, r0 <== NOT EXECUTED 3c578: e59f0384 ldr r0, [pc, #900] ; 3c904 <rtems_rfs_format+0xd2c><== NOT EXECUTED 3c57c: eb002bf9 bl 47568 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_fs_close (fs);
3c580: e59d00e4 ldr r0, [sp, #228] ; 0xe4 <== NOT EXECUTED 3c584: ebfffc10 bl 3b5cc <rtems_rfs_fs_close> <== NOT EXECUTED
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
{
printf ("rtems-rfs: format: writing root dir failed: %d: %s\n",
3c588: e1a00006 mov r0, r6 <== NOT EXECUTED 3c58c: eb003408 bl 495b4 <strerror> <== NOT EXECUTED 3c590: e1a01006 mov r1, r6 <== NOT EXECUTED 3c594: e1a02000 mov r2, r0 <== NOT EXECUTED 3c598: e59f0368 ldr r0, [pc, #872] ; 3c908 <rtems_rfs_format+0xd30><== NOT EXECUTED 3c59c: eb002bf1 bl 47568 <printf> <== NOT EXECUTED 3c5a0: e3e00000 mvn r0, #0 <== NOT EXECUTED
rc, strerror (rc));
return -1;
3c5a4: eafffe29 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
if (!rtems_rfs_write_group (&fs, group,
config->initialise_inodes, config->verbose))
return -1;
if (config->verbose)
printf ("\n");
3c5a8: e3a0000a mov r0, #10 <== NOT EXECUTED 3c5ac: eb002c62 bl 4773c <putchar> <== NOT EXECUTED 3c5b0: eaffffaa b 3c460 <rtems_rfs_format+0x888> <== NOT EXECUTED
}
rc = rtems_rfs_buffer_setblksize (&fs, rtems_rfs_fs_block_size (&fs));
if (rc > 0)
{
printf ("rtems-rfs: format: setting block size failed: %d: %s\n",
3c5b4: eb0033fe bl 495b4 <strerror> <== NOT EXECUTED 3c5b8: e1a01005 mov r1, r5 <== NOT EXECUTED 3c5bc: e1a02000 mov r2, r0 <== NOT EXECUTED 3c5c0: e59f0344 ldr r0, [pc, #836] ; 3c90c <rtems_rfs_format+0xd34><== NOT EXECUTED 3c5c4: eb002be7 bl 47568 <printf> <== NOT EXECUTED 3c5c8: e3e00000 mvn r0, #0 <== NOT EXECUTED
rc, strerror (rc));
return -1;
3c5cc: eafffe1f b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
if (total_size >= GIGS (1))
{
uint32_t gigs = (total_size + GIGS (1)) / GIGS (1);
int b;
for (b = 31; b > 0; b--)
3c5d0: e3a05001 mov r5, #1 <== NOT EXECUTED
if ((gigs & (1 << b)) != 0)
break;
fs->block_size = 1 << b;
3c5d4: e58d501c str r5, [sp, #28] <== NOT EXECUTED 3c5d8: eafffede b 3c158 <rtems_rfs_format+0x580> <== NOT EXECUTED
printf ("rtems-rfs: format: allocated inode not root ino: %" PRId32 "\n", ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
3c5dc: e28d5094 add r5, sp, #148 ; 0x94 <== NOT EXECUTED 3c5e0: e59d00e4 ldr r0, [sp, #228] ; 0xe4 <== NOT EXECUTED 3c5e4: e1a01004 mov r1, r4 <== NOT EXECUTED 3c5e8: e1a02005 mov r2, r5 <== NOT EXECUTED 3c5ec: e1a03004 mov r3, r4 <== NOT EXECUTED 3c5f0: eb00031b bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
3c5f4: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3c5f8: da00004f ble 3c73c <rtems_rfs_format+0xb64> <== NOT EXECUTED
{
printf ("rtems-rfs: format: inode open failed: %d: %s\n",
3c5fc: eb0033ec bl 495b4 <strerror> <== NOT EXECUTED 3c600: e1a01006 mov r1, r6 <== NOT EXECUTED 3c604: e1a02000 mov r2, r0 <== NOT EXECUTED 3c608: e59f0300 ldr r0, [pc, #768] ; 3c910 <rtems_rfs_format+0xd38><== NOT EXECUTED 3c60c: eb002bd5 bl 47568 <printf> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_group_bitmap_free (fs, true, ino);
3c610: e1a01004 mov r1, r4 <== NOT EXECUTED 3c614: e59d00e4 ldr r0, [sp, #228] ; 0xe4 <== NOT EXECUTED 3c618: e59d20e0 ldr r2, [sp, #224] ; 0xe0 <== NOT EXECUTED 3c61c: eb000120 bl 3caa4 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
rtems_rfs_fs_close (fs);
3c620: e59d00e4 ldr r0, [sp, #228] ; 0xe4 <== NOT EXECUTED 3c624: ebfffbe8 bl 3b5cc <rtems_rfs_fs_close> <== NOT EXECUTED 3c628: eaffffd6 b 3c588 <rtems_rfs_format+0x9b0> <== NOT EXECUTED
}
/*
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
3c62c: e1a0000a mov r0, sl <== NOT EXECUTED 3c630: eb00170a bl 42260 <rtems_rfs_bitmap_close> <== NOT EXECUTED
if (rc > 0)
3c634: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3c638: ca000033 bgt 3c70c <rtems_rfs_format+0xb34> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
3c63c: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
" bitmap failed: %d: %s\n", group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
3c640: e3a03001 mov r3, #1 <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
3c644: e3520000 cmp r2, #0 <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
" bitmap failed: %d: %s\n", group, rc, strerror (rc));
return false;
}
rtems_rfs_buffer_mark_dirty (&handle);
3c648: e5cd30d4 strb r3, [sp, #212] ; 0xd4 <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
3c64c: 0a000069 beq 3c7f8 <rtems_rfs_format+0xc20> <== NOT EXECUTED
{
for (b = 0; b < blocks; b++)
3c650: e59dc00c ldr ip, [sp, #12] <== NOT EXECUTED 3c654: e35c0000 cmp ip, #0 <== NOT EXECUTED 3c658: da000066 ble 3c7f8 <rtems_rfs_format+0xc20> <== NOT EXECUTED 3c65c: e2856002 add r6, r5, #2 <== NOT EXECUTED 3c660: e1a08007 mov r8, r7 <== NOT EXECUTED 3c664: e3a05000 mov r5, #0 <== NOT EXECUTED 3c668: e1a0700c mov r7, ip <== NOT EXECUTED 3c66c: ea000008 b 3c694 <rtems_rfs_format+0xabc> <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
3c670: e59d30dc ldr r3, [sp, #220] ; 0xdc <== NOT EXECUTED 3c674: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 3c678: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 3c67c: eb002792 bl 464cc <memset> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
3c680: e3a01001 mov r1, #1 <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
3c684: e1550007 cmp r5, r7 <== NOT EXECUTED
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
rtems_rfs_buffer_mark_dirty (&handle);
3c688: e5cd10d4 strb r1, [sp, #212] ; 0xd4 <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
3c68c: e2866001 add r6, r6, #1 <== NOT EXECUTED 3c690: aa000057 bge 3c7f4 <rtems_rfs_format+0xc1c> <== NOT EXECUTED
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
3c694: e28d10d4 add r1, sp, #212 ; 0xd4 <== NOT EXECUTED 3c698: e1a02006 mov r2, r6 <== NOT EXECUTED 3c69c: e3a03000 mov r3, #0 <== NOT EXECUTED 3c6a0: e1a00004 mov r0, r4 <== NOT EXECUTED 3c6a4: ebfff4ea bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
3c6a8: e3500000 cmp r0, #0 <== NOT EXECUTED
/*
* Initialise the inode tables if required to do so.
*/
if (initialise_inodes)
{
for (b = 0; b < blocks; b++)
3c6ac: e2855001 add r5, r5, #1 <== NOT EXECUTED
/*
* Force the whole buffer to a known state. The bit map may not occupy the
* whole block.
*/
memset (rtems_rfs_buffer_data (&handle), 0xff, rtems_rfs_fs_block_size (fs));
3c6b0: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED
for (b = 0; b < blocks; b++)
{
rc = rtems_rfs_buffer_handle_request (fs, &handle,
group_base + b + RTEMS_RFS_GROUP_INODE_BLOCK,
false);
if (rc > 0)
3c6b4: daffffed ble 3c670 <rtems_rfs_format+0xa98> <== NOT EXECUTED 3c6b8: e1a08000 mov r8, r0 <== NOT EXECUTED
{
rtems_rfs_buffer_handle_close (fs, &handle);
3c6bc: e28d10d4 add r1, sp, #212 ; 0xd4 <== NOT EXECUTED 3c6c0: e1a00004 mov r0, r4 <== NOT EXECUTED 3c6c4: ebfffd3b bl 3bbb8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: block %" PRId32 " request failed: %d: %s\n",
3c6c8: e1a00008 mov r0, r8 <== NOT EXECUTED 3c6cc: eb0033b8 bl 495b4 <strerror> <== NOT EXECUTED 3c6d0: e1a01009 mov r1, r9 <== NOT EXECUTED 3c6d4: e58d0000 str r0, [sp] <== NOT EXECUTED 3c6d8: e1a02006 mov r2, r6 <== NOT EXECUTED 3c6dc: e1a03008 mov r3, r8 <== NOT EXECUTED 3c6e0: e59f022c ldr r0, [pc, #556] ; 3c914 <rtems_rfs_format+0xd3c><== NOT EXECUTED 3c6e4: eb002b9f bl 47568 <printf> <== NOT EXECUTED 3c6e8: e3e00000 mvn r0, #0 <== NOT EXECUTED 3c6ec: eafffdd7 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
printf ("\n");
rc = rtems_rfs_buffer_close (&fs);
if (rc > 0)
{
printf ("rtems-rfs: format: buffer close failed: %d: %s\n",
3c6f0: eb0033af bl 495b4 <strerror> <== NOT EXECUTED 3c6f4: e1a01004 mov r1, r4 <== NOT EXECUTED 3c6f8: e1a02000 mov r2, r0 <== NOT EXECUTED 3c6fc: e59f0214 ldr r0, [pc, #532] ; 3c918 <rtems_rfs_format+0xd40><== NOT EXECUTED 3c700: eb002b98 bl 47568 <printf> <== NOT EXECUTED 3c704: e3e00000 mvn r0, #0 <== NOT EXECUTED
rc, strerror (rc));
return -1;
3c708: eafffdd0 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
* Close the inode bitmap.
*/
rc = rtems_rfs_bitmap_close (&bitmap);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &handle);
3c70c: e28d10d4 add r1, sp, #212 ; 0xd4 <== NOT EXECUTED 3c710: e1a00004 mov r0, r4 <== NOT EXECUTED 3c714: ebfffd27 bl 3bbb8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
printf ("\nrtems-rfs: write-group: group %3d: close inode" \
3c718: e1a00006 mov r0, r6 <== NOT EXECUTED 3c71c: eb0033a4 bl 495b4 <strerror> <== NOT EXECUTED 3c720: e1a01009 mov r1, r9 <== NOT EXECUTED 3c724: e1a03000 mov r3, r0 <== NOT EXECUTED 3c728: e1a02006 mov r2, r6 <== NOT EXECUTED 3c72c: e59f01e8 ldr r0, [pc, #488] ; 3c91c <rtems_rfs_format+0xd44><== NOT EXECUTED 3c730: eb002b8c bl 47568 <printf> <== NOT EXECUTED 3c734: e3e00000 mvn r0, #0 <== NOT EXECUTED 3c738: eafffdc4 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
rtems_rfs_group_bitmap_free (fs, true, ino);
rtems_rfs_fs_close (fs);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, 0,
3c73c: e3a0c000 mov ip, #0 <== NOT EXECUTED 3c740: e3a02c41 mov r2, #16640 ; 0x4100 <== NOT EXECUTED 3c744: e1a0100c mov r1, ip <== NOT EXECUTED 3c748: e28220c9 add r2, r2, #201 ; 0xc9 <== NOT EXECUTED 3c74c: e1a00005 mov r0, r5 <== NOT EXECUTED 3c750: e1a0300c mov r3, ip <== NOT EXECUTED 3c754: e58dc000 str ip, [sp] <== NOT EXECUTED 3c758: eb000217 bl 3cfbc <rtems_rfs_inode_initialise> <== NOT EXECUTED
(RTEMS_RFS_S_IFDIR | RTEMS_RFS_S_IRWXU |
RTEMS_RFS_S_IXGRP | RTEMS_RFS_S_IXOTH),
0, 0);
if (rc > 0)
3c75c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3c760: da000004 ble 3c778 <rtems_rfs_format+0xba0> <== NOT EXECUTED
printf ("rtems-rfs: format: inode initialise failed: %d: %s\n",
3c764: eb003392 bl 495b4 <strerror> <== NOT EXECUTED 3c768: e1a01004 mov r1, r4 <== NOT EXECUTED 3c76c: e1a02000 mov r2, r0 <== NOT EXECUTED 3c770: e59f01a8 ldr r0, [pc, #424] ; 3c920 <rtems_rfs_format+0xd48><== NOT EXECUTED 3c774: eb002b7b bl 47568 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, ino);
3c778: e59dc0e0 ldr ip, [sp, #224] ; 0xe0 <== NOT EXECUTED 3c77c: e59d00e4 ldr r0, [sp, #228] ; 0xe4 <== NOT EXECUTED 3c780: e1a01005 mov r1, r5 <== NOT EXECUTED 3c784: e59f2198 ldr r2, [pc, #408] ; 3c924 <rtems_rfs_format+0xd4c><== NOT EXECUTED 3c788: e3a03001 mov r3, #1 <== NOT EXECUTED 3c78c: e58dc000 str ip, [sp] <== NOT EXECUTED 3c790: ebfff6bc bl 3a288 <rtems_rfs_dir_add_entry> <== NOT EXECUTED
if (rc > 0)
3c794: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3c798: da000004 ble 3c7b0 <rtems_rfs_format+0xbd8> <== NOT EXECUTED
printf ("rtems-rfs: format: directory add failed: %d: %s\n",
3c79c: eb003384 bl 495b4 <strerror> <== NOT EXECUTED 3c7a0: e1a01004 mov r1, r4 <== NOT EXECUTED 3c7a4: e1a02000 mov r2, r0 <== NOT EXECUTED 3c7a8: e59f0178 ldr r0, [pc, #376] ; 3c928 <rtems_rfs_format+0xd50><== NOT EXECUTED 3c7ac: eb002b6d bl 47568 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_inode_close (fs, &inode);
3c7b0: e1a01005 mov r1, r5 <== NOT EXECUTED 3c7b4: e59d00e4 ldr r0, [sp, #228] ; 0xe4 <== NOT EXECUTED 3c7b8: eb000285 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
3c7bc: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3c7c0: da000004 ble 3c7d8 <rtems_rfs_format+0xc00> <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
3c7c4: eb00337a bl 495b4 <strerror> <== NOT EXECUTED 3c7c8: e1a01004 mov r1, r4 <== NOT EXECUTED 3c7cc: e1a02000 mov r2, r0 <== NOT EXECUTED 3c7d0: e59f0154 ldr r0, [pc, #340] ; 3c92c <rtems_rfs_format+0xd54><== NOT EXECUTED 3c7d4: eb002b63 bl 47568 <printf> <== NOT EXECUTED
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
3c7d8: e59d00e4 ldr r0, [sp, #228] ; 0xe4 <== NOT EXECUTED 3c7dc: ebfffb7a bl 3b5cc <rtems_rfs_fs_close> <== NOT EXECUTED
if (rc < 0)
3c7e0: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3c7e4: ba00001a blt 3c854 <rtems_rfs_format+0xc7c> <== NOT EXECUTED
rc, strerror (rc));
return -1;
}
rc = rtems_rfs_write_root_dir (name);
if (rc > 0)
3c7e8: 01a00006 moveq r0, r6 <== NOT EXECUTED 3c7ec: 0afffd97 beq 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED 3c7f0: eaffff64 b 3c588 <rtems_rfs_format+0x9b0> <== NOT EXECUTED 3c7f4: e1a07008 mov r7, r8 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle);
}
}
rc = rtems_rfs_buffer_handle_close (fs, &handle);
3c7f8: e1a00004 mov r0, r4 <== NOT EXECUTED 3c7fc: e28d10d4 add r1, sp, #212 ; 0xd4 <== NOT EXECUTED 3c800: ebfffcec bl 3bbb8 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
if (rc > 0)
3c804: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3c808: dafffec5 ble 3c324 <rtems_rfs_format+0x74c> <== NOT EXECUTED
{
printf ("\nrtems-rfs: write-group: buffer handle close failed: %d: %s\n",
3c80c: eb003368 bl 495b4 <strerror> <== NOT EXECUTED 3c810: e1a01005 mov r1, r5 <== NOT EXECUTED 3c814: e1a02000 mov r2, r0 <== NOT EXECUTED 3c818: e59f0110 ldr r0, [pc, #272] ; 3c930 <rtems_rfs_format+0xd58><== NOT EXECUTED 3c81c: eb002b51 bl 47568 <printf> <== NOT EXECUTED 3c820: e3e00000 mvn r0, #0 <== NOT EXECUTED 3c824: eafffd89 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
rc = rtems_rfs_fs_open (name, NULL,
RTEMS_RFS_FS_FORCE_OPEN | RTEMS_RFS_FS_NO_LOCAL_CACHE,
0, &fs);
if (rc < 0)
{
printf ("rtems-rfs: format: file system open failed: %d: %s\n",
3c828: eb0019f0 bl 42ff0 <__errno> <== NOT EXECUTED 3c82c: e5904000 ldr r4, [r0] <== NOT EXECUTED 3c830: eb0019ee bl 42ff0 <__errno> <== NOT EXECUTED 3c834: e5900000 ldr r0, [r0] <== NOT EXECUTED 3c838: eb00335d bl 495b4 <strerror> <== NOT EXECUTED 3c83c: e1a01004 mov r1, r4 <== NOT EXECUTED 3c840: e1a02000 mov r2, r0 <== NOT EXECUTED 3c844: e59f00e8 ldr r0, [pc, #232] ; 3c934 <rtems_rfs_format+0xd5c><== NOT EXECUTED 3c848: eb002b46 bl 47568 <printf> <== NOT EXECUTED 3c84c: e3a00000 mov r0, #0 <== NOT EXECUTED 3c850: eafffd7e b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
printf ("rtems-rfs: format: inode close failed: %d: %s\n",
rc, strerror (rc));
rc = rtems_rfs_fs_close (fs);
if (rc < 0)
printf ("rtems-rfs: format: file system close failed: %d: %s\n",
3c854: eb0019e5 bl 42ff0 <__errno> <== NOT EXECUTED 3c858: e5904000 ldr r4, [r0] <== NOT EXECUTED 3c85c: eb0019e3 bl 42ff0 <__errno> <== NOT EXECUTED 3c860: e5900000 ldr r0, [r0] <== NOT EXECUTED 3c864: eb003352 bl 495b4 <strerror> <== NOT EXECUTED 3c868: e1a01004 mov r1, r4 <== NOT EXECUTED 3c86c: e1a02000 mov r2, r0 <== NOT EXECUTED 3c870: e59f00c0 ldr r0, [pc, #192] ; 3c938 <rtems_rfs_format+0xd60><== NOT EXECUTED 3c874: eb002b3b bl 47568 <printf> <== NOT EXECUTED 3c878: e3a00000 mov r0, #0 <== NOT EXECUTED 3c87c: eafffd73 b 3be50 <rtems_rfs_format+0x278> <== NOT EXECUTED
0003b5cc <rtems_rfs_fs_close>:
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
3b5cc: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED 3b5d0: e3530000 cmp r3, #0 <== NOT EXECUTED
return 0;
}
int
rtems_rfs_fs_close (rtems_rfs_file_system* fs)
{
3b5d4: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3b5d8: e1a04000 mov r4, r0 <== NOT EXECUTED
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
3b5dc: da00000a ble 3b60c <rtems_rfs_fs_close+0x40> <== NOT EXECUTED 3b5e0: e3a05000 mov r5, #0 <== NOT EXECUTED 3b5e4: e1a06005 mov r6, r5 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[group]);
3b5e8: e594101c ldr r1, [r4, #28] <== NOT EXECUTED 3b5ec: e1a00004 mov r0, r4 <== NOT EXECUTED 3b5f0: e0811005 add r1, r1, r5 <== NOT EXECUTED 3b5f4: eb0005cc bl 3cd2c <rtems_rfs_group_close> <== NOT EXECUTED
int group;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_CLOSE))
printf ("rtems-rfs: close\n");
for (group = 0; group < fs->group_count; group++)
3b5f8: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED 3b5fc: e2866001 add r6, r6, #1 <== NOT EXECUTED 3b600: e1530006 cmp r3, r6 <== NOT EXECUTED 3b604: e2855050 add r5, r5, #80 ; 0x50 <== NOT EXECUTED 3b608: cafffff6 bgt 3b5e8 <rtems_rfs_fs_close+0x1c> <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[group]);
rtems_rfs_buffer_close (fs);
3b60c: e1a00004 mov r0, r4 <== NOT EXECUTED 3b610: ebfff8a4 bl 398a8 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (fs);
3b614: e1a00004 mov r0, r4 <== NOT EXECUTED 3b618: ebff31d4 bl 7d70 <free> <== NOT EXECUTED
return 0; }
3b61c: e3a00000 mov r0, #0 <== NOT EXECUTED
3b620: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0003b5a8 <rtems_rfs_fs_media_size>:
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
3b5a8: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 3b5ac: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED 3b5b0: e593201c ldr r2, [r3, #28] <== NOT EXECUTED
return blocks * block_size;
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
3b5b4: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
3b5b8: e0843291 umull r3, r4, r1, r2 <== NOT EXECUTED
uint64_t media_block_size = (uint64_t) rtems_rfs_fs_media_block_size (fs); return media_blocks * media_block_size; }
3b5bc: e1a01004 mov r1, r4 <== NOT EXECUTED
3b5c0: e1a00003 mov r0, r3 <== NOT EXECUTED
3b5c4: e8bd0010 pop {r4} <== NOT EXECUTED
3b5c8: e12fff1e bx lr <== NOT EXECUTED
0003b644 <rtems_rfs_fs_open>:
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
uint32_t max_held_buffers,
rtems_rfs_file_system** fs)
{
3b644: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3b648: e24dd03c sub sp, sp, #60 ; 0x3c <== NOT EXECUTED
3b64c: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
3b650: e3a00080 mov r0, #128 ; 0x80 <== NOT EXECUTED
rtems_rfs_fs_open (const char* name,
void* user,
uint32_t flags,
uint32_t max_held_buffers,
rtems_rfs_file_system** fs)
{
3b654: e59d5060 ldr r5, [sp, #96] ; 0x60 <== NOT EXECUTED 3b658: e1a07001 mov r7, r1 <== NOT EXECUTED 3b65c: e1a06002 mov r6, r2 <== NOT EXECUTED 3b660: e1a08003 mov r8, r3 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
3b664: ebff3385 bl 8480 <malloc> <== NOT EXECUTED
if (!*fs)
3b668: e3500000 cmp r0, #0 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: %s\n", name);
*fs = malloc (sizeof (rtems_rfs_file_system));
3b66c: e5850000 str r0, [r5] <== NOT EXECUTED
if (!*fs)
3b670: 0a0000c8 beq 3b998 <rtems_rfs_fs_open+0x354> <== NOT EXECUTED
printf ("rtems-rfs: open: no memory for file system data\n");
errno = ENOMEM;
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
3b674: e3a01000 mov r1, #0 <== NOT EXECUTED 3b678: e3a02080 mov r2, #128 ; 0x80 <== NOT EXECUTED 3b67c: eb002b92 bl 464cc <memset> <== NOT EXECUTED
(*fs)->user = user;
3b680: e5951000 ldr r1, [r5] <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
3b684: e3a04000 mov r4, #0 <== NOT EXECUTED
the_chain->last = _Chain_Head(the_chain);
3b688: e2810060 add r0, r1, #96 ; 0x60 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
3b68c: e281b044 add fp, r1, #68 ; 0x44 <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
3b690: e2819040 add r9, r1, #64 ; 0x40 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
3b694: e281a054 add sl, r1, #84 ; 0x54 <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
3b698: e281e050 add lr, r1, #80 ; 0x50 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
3b69c: e281c064 add ip, r1, #100 ; 0x64 <== NOT EXECUTED 3b6a0: e2812074 add r2, r1, #116 ; 0x74 <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
3b6a4: e2813070 add r3, r1, #112 ; 0x70 <== NOT EXECUTED 3b6a8: e5810068 str r0, [r1, #104] ; 0x68 <== NOT EXECUTED
(*fs)->max_held_buffers = max_held_buffers;
(*fs)->buffers_count = 0;
(*fs)->release_count = 0;
(*fs)->release_modified_count = 0;
(*fs)->flags = flags;
3b6ac: e5816000 str r6, [r1] <== NOT EXECUTED
return -1;
}
memset (*fs, 0, sizeof (rtems_rfs_file_system));
(*fs)->user = user;
3b6b0: e581707c str r7, [r1, #124] ; 0x7c <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
3b6b4: e581b040 str fp, [r1, #64] ; 0x40 <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
3b6b8: e5819048 str r9, [r1, #72] ; 0x48 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
3b6bc: e581a050 str sl, [r1, #80] ; 0x50 <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
3b6c0: e581e058 str lr, [r1, #88] ; 0x58 <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
3b6c4: e581c060 str ip, [r1, #96] ; 0x60 <== NOT EXECUTED 3b6c8: e5812070 str r2, [r1, #112] ; 0x70 <== NOT EXECUTED
the_chain->permanent_null = NULL; the_chain->last = _Chain_Head(the_chain);
3b6cc: e5813078 str r3, [r1, #120] ; 0x78 <== NOT EXECUTED
rtems_chain_initialize_empty (&(*fs)->buffers);
rtems_chain_initialize_empty (&(*fs)->release);
rtems_chain_initialize_empty (&(*fs)->release_modified);
rtems_chain_initialize_empty (&(*fs)->file_shares);
(*fs)->max_held_buffers = max_held_buffers;
3b6d0: e581803c str r8, [r1, #60] ; 0x3c <== NOT EXECUTED
RTEMS_INLINE_ROUTINE void _Chain_Initialize_empty(
Chain_Control *the_chain
)
{
the_chain->first = _Chain_Tail(the_chain);
the_chain->permanent_null = NULL;
3b6d4: e5814044 str r4, [r1, #68] ; 0x44 <== NOT EXECUTED 3b6d8: e5814054 str r4, [r1, #84] ; 0x54 <== NOT EXECUTED 3b6dc: e5814064 str r4, [r1, #100] ; 0x64 <== NOT EXECUTED 3b6e0: e5814074 str r4, [r1, #116] ; 0x74 <== NOT EXECUTED
(*fs)->buffers_count = 0;
3b6e4: e581404c str r4, [r1, #76] ; 0x4c <== NOT EXECUTED
(*fs)->release_count = 0;
3b6e8: e581405c str r4, [r1, #92] ; 0x5c <== NOT EXECUTED
(*fs)->release_modified_count = 0;
3b6ec: e581406c str r4, [r1, #108] ; 0x6c <== NOT EXECUTED
group_base = 0;
/*
* Open the buffer interface.
*/
rc = rtems_rfs_buffer_open (name, *fs);
3b6f0: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 3b6f4: ebfff875 bl 398d0 <rtems_rfs_buffer_open> <== NOT EXECUTED
if (rc > 0)
3b6f8: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3b6fc: ca00002b bgt 3b7b0 <rtems_rfs_fs_open+0x16c> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_fs_read_superblock (*fs);
3b700: e5956000 ldr r6, [r5] <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: handle open failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &handle, 0, true);
3b704: e28d7030 add r7, sp, #48 ; 0x30 <== NOT EXECUTED 3b708: e1a00006 mov r0, r6 <== NOT EXECUTED 3b70c: e1a01007 mov r1, r7 <== NOT EXECUTED 3b710: e1a02004 mov r2, r4 <== NOT EXECUTED 3b714: e3a03001 mov r3, #1 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
3b718: e5cd4030 strb r4, [sp, #48] ; 0x30 <== NOT EXECUTED
handle->bnum = 0;
3b71c: e58d4034 str r4, [sp, #52] ; 0x34 <== NOT EXECUTED
handle->buffer = NULL;
3b720: e58d4038 str r4, [sp, #56] ; 0x38 <== NOT EXECUTED 3b724: ebfff8ca bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
3b728: e250a000 subs sl, r0, #0 <== NOT EXECUTED 3b72c: da000008 ble 3b754 <rtems_rfs_fs_open+0x110> <== NOT EXECUTED
}
rc = rtems_rfs_fs_read_superblock (*fs);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
3b730: e5950000 ldr r0, [r5] <== NOT EXECUTED 3b734: ebfff85b bl 398a8 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
3b738: e5950000 ldr r0, [r5] <== NOT EXECUTED 3b73c: ebff318b bl 7d70 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: reading superblock: %d: %s\n",
rc, strerror (rc));
errno = rc;
3b740: eb001e2a bl 42ff0 <__errno> <== NOT EXECUTED 3b744: e580a000 str sl, [r0] <== NOT EXECUTED 3b748: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
}
errno = 0;
return 0;
}
3b74c: e28dd03c add sp, sp, #60 ; 0x3c <== NOT EXECUTED
3b750: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: request failed%d: %s\n",
rc, strerror (rc));
return rc;
}
sb = rtems_rfs_buffer_data (&handle);
3b754: e59d3038 ldr r3, [sp, #56] ; 0x38 <== NOT EXECUTED 3b758: e5933020 ldr r3, [r3, #32] <== NOT EXECUTED
#define read_sb(_o) rtems_rfs_read_u32 (sb + (_o))
if (read_sb (RTEMS_RFS_SB_OFFSET_MAGIC) != RTEMS_RFS_SB_MAGIC)
3b75c: e5d30000 ldrb r0, [r3] <== NOT EXECUTED 3b760: e5d31003 ldrb r1, [r3, #3] <== NOT EXECUTED 3b764: e5d32001 ldrb r2, [r3, #1] <== NOT EXECUTED 3b768: e1811c00 orr r1, r1, r0, lsl #24 <== NOT EXECUTED 3b76c: e5d30002 ldrb r0, [r3, #2] <== NOT EXECUTED 3b770: e1811802 orr r1, r1, r2, lsl #16 <== NOT EXECUTED 3b774: e3a0234a mov r2, #671088641 ; 0x28000001 <== NOT EXECUTED 3b778: e1811400 orr r1, r1, r0, lsl #8 <== NOT EXECUTED 3b77c: e2822a92 add r2, r2, #598016 ; 0x92000 <== NOT EXECUTED 3b780: e1510002 cmp r1, r2 <== NOT EXECUTED 3b784: 0a00000f beq 3b7c8 <rtems_rfs_fs_open+0x184> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3b788: e1a00006 mov r0, r6 <== NOT EXECUTED 3b78c: e1a01007 mov r1, r7 <== NOT EXECUTED 3b790: ebfff865 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false; handle->bnum = 0; handle->buffer = NULL;
3b794: e3a0a005 mov sl, #5 <== NOT EXECUTED 3b798: e58d4038 str r4, [sp, #56] ; 0x38 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3b79c: e5cd4030 strb r4, [sp, #48] ; 0x30 <== NOT EXECUTED
handle->bnum = 0;
3b7a0: e58d4034 str r4, [sp, #52] ; 0x34 <== NOT EXECUTED 3b7a4: eaffffe1 b 3b730 <rtems_rfs_fs_open+0xec> <== NOT EXECUTED
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
3b7a8: e5950000 ldr r0, [r5] <== NOT EXECUTED 3b7ac: ebfff83d bl 398a8 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
3b7b0: e5950000 ldr r0, [r5] <== NOT EXECUTED 3b7b4: ebff316d bl 7d70 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: reading root inode: %d: %s\n",
rc, strerror (rc));
errno = rc;
3b7b8: eb001e0c bl 42ff0 <__errno> <== NOT EXECUTED 3b7bc: e5806000 str r6, [r0] <== NOT EXECUTED 3b7c0: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
3b7c4: eaffffe0 b 3b74c <rtems_rfs_fs_open+0x108> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock, bad magic\n");
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
3b7c8: e5d3100d ldrb r1, [r3, #13] <== NOT EXECUTED 3b7cc: e5d3200c ldrb r2, [r3, #12] <== NOT EXECUTED 3b7d0: e5d3000f ldrb r0, [r3, #15] <== NOT EXECUTED 3b7d4: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3b7d8: e1811c02 orr r1, r1, r2, lsl #24 <== NOT EXECUTED 3b7dc: e5d3200e ldrb r2, [r3, #14] <== NOT EXECUTED 3b7e0: e1811000 orr r1, r1, r0 <== NOT EXECUTED 3b7e4: e1811402 orr r1, r1, r2, lsl #8 <== NOT EXECUTED 3b7e8: e5861004 str r1, [r6, #4] <== NOT EXECUTED
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
3b7ec: e5d32009 ldrb r2, [r3, #9] <== NOT EXECUTED 3b7f0: e5d30008 ldrb r0, [r3, #8] <== NOT EXECUTED 3b7f4: e5d3c00b ldrb ip, [r3, #11] <== NOT EXECUTED 3b7f8: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED 3b7fc: e1822c00 orr r2, r2, r0, lsl #24 <== NOT EXECUTED 3b800: e5d3000a ldrb r0, [r3, #10] <== NOT EXECUTED 3b804: e182200c orr r2, r2, ip <== NOT EXECUTED 3b808: e1822400 orr r2, r2, r0, lsl #8 <== NOT EXECUTED 3b80c: e5862008 str r2, [r6, #8] <== NOT EXECUTED
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
3b810: e596000c ldr r0, [r6, #12] <== NOT EXECUTED 3b814: e590c01c ldr ip, [r0, #28] <== NOT EXECUTED 3b818: e5900024 ldr r0, [r0, #36] ; 0x24 <== NOT EXECUTED
}
fs->blocks = read_sb (RTEMS_RFS_SB_OFFSET_BLOCKS);
fs->block_size = read_sb (RTEMS_RFS_SB_OFFSET_BLOCK_SIZE);
if (rtems_rfs_fs_size(fs) > rtems_rfs_fs_media_size (fs))
3b81c: e08ba192 umull sl, fp, r2, r1 <== NOT EXECUTED
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
3b820: e0898c90 umull r8, r9, r0, ip <== NOT EXECUTED 3b824: e15b0009 cmp fp, r9 <== NOT EXECUTED 3b828: 8a00000a bhi 3b858 <rtems_rfs_fs_open+0x214> <== NOT EXECUTED 3b82c: 0a00000e beq 3b86c <rtems_rfs_fs_open+0x228> <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
if (read_sb (RTEMS_RFS_SB_OFFSET_INODE_SIZE) != RTEMS_RFS_INODE_SIZE)
3b830: e5d31025 ldrb r1, [r3, #37] ; 0x25 <== NOT EXECUTED 3b834: e5d30024 ldrb r0, [r3, #36] ; 0x24 <== NOT EXECUTED 3b838: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3b83c: e5d3c027 ldrb ip, [r3, #39] ; 0x27 <== NOT EXECUTED 3b840: e1811c00 orr r1, r1, r0, lsl #24 <== NOT EXECUTED 3b844: e5d30026 ldrb r0, [r3, #38] ; 0x26 <== NOT EXECUTED 3b848: e181100c orr r1, r1, ip <== NOT EXECUTED 3b84c: e1811400 orr r1, r1, r0, lsl #8 <== NOT EXECUTED 3b850: e3510038 cmp r1, #56 ; 0x38 <== NOT EXECUTED 3b854: 0a000007 beq 3b878 <rtems_rfs_fs_open+0x234> <== NOT EXECUTED
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs)))
{
rtems_rfs_buffer_handle_close (fs, &handle);
3b858: e1a00006 mov r0, r6 <== NOT EXECUTED 3b85c: e1a01007 mov r1, r7 <== NOT EXECUTED 3b860: ebffff6f bl 3b624 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED 3b864: e3a0a005 mov sl, #5 <== NOT EXECUTED 3b868: eaffffb0 b 3b730 <rtems_rfs_fs_open+0xec> <== NOT EXECUTED
}
uint64_t
rtems_rfs_fs_media_size (rtems_rfs_file_system* fs)
{
uint64_t media_blocks = (uint64_t) rtems_rfs_fs_media_blocks (fs);
3b86c: e15a0008 cmp sl, r8 <== NOT EXECUTED 3b870: 9affffee bls 3b830 <rtems_rfs_fs_open+0x1ec> <== NOT EXECUTED 3b874: eafffff7 b 3b858 <rtems_rfs_fs_open+0x214> <== NOT EXECUTED
read_sb (RTEMS_RFS_SB_OFFSET_VERSION), RTEMS_RFS_VERSION_MASK);
rtems_rfs_buffer_handle_close (fs, &handle);
return EIO;
}
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
3b878: e5d31011 ldrb r1, [r3, #17] <== NOT EXECUTED 3b87c: e5d30010 ldrb r0, [r3, #16] <== NOT EXECUTED 3b880: e5d3c013 ldrb ip, [r3, #19] <== NOT EXECUTED 3b884: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3b888: e1811c00 orr r1, r1, r0, lsl #24 <== NOT EXECUTED 3b88c: e5d30012 ldrb r0, [r3, #18] <== NOT EXECUTED 3b890: e181100c orr r1, r1, ip <== NOT EXECUTED 3b894: e1811400 orr r1, r1, r0, lsl #8 <== NOT EXECUTED 3b898: e5861014 str r1, [r6, #20] <== NOT EXECUTED
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
3b89c: e5d31015 ldrb r1, [r3, #21] <== NOT EXECUTED 3b8a0: e5d30014 ldrb r0, [r3, #20] <== NOT EXECUTED 3b8a4: e5d3c017 ldrb ip, [r3, #23] <== NOT EXECUTED 3b8a8: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3b8ac: e1811c00 orr r1, r1, r0, lsl #24 <== NOT EXECUTED 3b8b0: e5d30016 ldrb r0, [r3, #22] <== NOT EXECUTED 3b8b4: e181100c orr r1, r1, ip <== NOT EXECUTED 3b8b8: e1811400 orr r1, r1, r0, lsl #8 <== NOT EXECUTED 3b8bc: e5861018 str r1, [r6, #24] <== NOT EXECUTED
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
3b8c0: e5d31019 ldrb r1, [r3, #25] <== NOT EXECUTED 3b8c4: e5d3c018 ldrb ip, [r3, #24] <== NOT EXECUTED 3b8c8: e5d3001b ldrb r0, [r3, #27] <== NOT EXECUTED 3b8cc: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3b8d0: e5d3e01a ldrb lr, [r3, #26] <== NOT EXECUTED 3b8d4: e1811c0c orr r1, r1, ip, lsl #24 <== NOT EXECUTED 3b8d8: e1811000 orr r1, r1, r0 <== NOT EXECUTED 3b8dc: e181e40e orr lr, r1, lr, lsl #8 <== NOT EXECUTED 3b8e0: e586e020 str lr, [r6, #32] <== NOT EXECUTED
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
3b8e4: e5d3101d ldrb r1, [r3, #29] <== NOT EXECUTED 3b8e8: e5d3c01c ldrb ip, [r3, #28] <== NOT EXECUTED 3b8ec: e5d3001f ldrb r0, [r3, #31] <== NOT EXECUTED 3b8f0: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3b8f4: e1811c0c orr r1, r1, ip, lsl #24 <== NOT EXECUTED 3b8f8: e5d3c01e ldrb ip, [r3, #30] <== NOT EXECUTED 3b8fc: e1811000 orr r1, r1, r0 <== NOT EXECUTED 3b900: e181c40c orr ip, r1, ip, lsl #8 <== NOT EXECUTED 3b904: e586c024 str ip, [r6, #36] ; 0x24 <== NOT EXECUTED
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
3b908: e5d31021 ldrb r1, [r3, #33] ; 0x21 <== NOT EXECUTED 3b90c: e5d30020 ldrb r0, [r3, #32] <== NOT EXECUTED 3b910: e5d34023 ldrb r4, [r3, #35] ; 0x23 <== NOT EXECUTED 3b914: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED 3b918: e1811c00 orr r1, r1, r0, lsl #24 <== NOT EXECUTED 3b91c: e5d30022 ldrb r0, [r3, #34] ; 0x22 <== NOT EXECUTED 3b920: e1811004 orr r1, r1, r4 <== NOT EXECUTED
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
3b924: e1a03122 lsr r3, r2, #2 <== NOT EXECUTED
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
3b928: e59f8208 ldr r8, [pc, #520] ; 3bb38 <rtems_rfs_fs_open+0x4f4><== NOT EXECUTED
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
3b92c: e1811400 orr r1, r1, r0, lsl #8 <== NOT EXECUTED
fs->block_map_doubly_blocks =
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
3b930: e1a0a1a2 lsr sl, r2, #3 <== NOT EXECUTED
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
3b934: e0000393 mul r0, r3, r3 <== NOT EXECUTED
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
3b938: e004019e mul r4, lr, r1 <== NOT EXECUTED
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
3b93c: e08e9a98 umull r9, lr, r8, sl <== NOT EXECUTED
if (fs->group_blocks >
3b940: e15c0182 cmp ip, r2, lsl #3 <== NOT EXECUTED
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
3b944: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
fs->blocks_per_block =
rtems_rfs_fs_block_size (fs) / sizeof (rtems_rfs_inode_block);
fs->block_map_singly_blocks =
3b948: e0832103 add r2, r3, r3, lsl #2 <== NOT EXECUTED 3b94c: e5862034 str r2, [r6, #52] ; 0x34 <== NOT EXECUTED
fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->block_map_doubly_blocks =
3b950: e5860038 str r0, [r6, #56] ; 0x38 <== NOT EXECUTED
fs->blocks_per_block * fs->blocks_per_block * RTEMS_RFS_INODE_BLOCKS;
fs->inodes = fs->group_count * fs->group_inodes;
3b954: e5864010 str r4, [r6, #16] <== NOT EXECUTED
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
3b958: e586e02c str lr, [r6, #44] ; 0x2c <== NOT EXECUTED
fs->bad_blocks = read_sb (RTEMS_RFS_SB_OFFSET_BAD_BLOCKS);
fs->max_name_length = read_sb (RTEMS_RFS_SB_OFFSET_MAX_NAME_LENGTH);
fs->group_count = read_sb (RTEMS_RFS_SB_OFFSET_GROUPS);
fs->group_blocks = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_BLOCKS);
fs->group_inodes = read_sb (RTEMS_RFS_SB_OFFSET_GROUP_INODES);
3b95c: e5861028 str r1, [r6, #40] ; 0x28 <== NOT EXECUTED
fs->blocks_per_block =
3b960: e5863030 str r3, [r6, #48] ; 0x30 <== NOT EXECUTED
fs->inodes = fs->group_count * fs->group_inodes;
fs->inodes_per_block = fs->block_size / RTEMS_RFS_INODE_SIZE;
if (fs->group_blocks >
3b964: 8affffbb bhi 3b858 <rtems_rfs_fs_open+0x214> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: read-superblock: groups blocks larger than block bits\n");
return EIO;
}
rtems_rfs_buffer_handle_close (fs, &handle);
3b968: e1a01007 mov r1, r7 <== NOT EXECUTED 3b96c: e1a00006 mov r0, r6 <== NOT EXECUTED 3b970: ebffff2b bl 3b624 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED
/*
* Change the block size to the value in the superblock.
*/
rc = rtems_rfs_buffer_setblksize (fs, rtems_rfs_fs_block_size (fs));
3b974: e1a00006 mov r0, r6 <== NOT EXECUTED 3b978: e5961008 ldr r1, [r6, #8] <== NOT EXECUTED 3b97c: ebfff7b2 bl 3984c <rtems_rfs_buffer_setblksize> <== NOT EXECUTED
if (rc > 0)
3b980: e250a000 subs sl, r0, #0 <== NOT EXECUTED 3b984: da000008 ble 3b9ac <rtems_rfs_fs_open+0x368> <== NOT EXECUTED
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
rtems_rfs_group_close (fs, &fs->groups[g]);
rtems_rfs_buffer_handle_close (fs, &handle);
3b988: e1a00006 mov r0, r6 <== NOT EXECUTED 3b98c: e1a01007 mov r1, r7 <== NOT EXECUTED 3b990: ebffff23 bl 3b624 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED 3b994: eaffff65 b 3b730 <rtems_rfs_fs_open+0xec> <== NOT EXECUTED
*fs = malloc (sizeof (rtems_rfs_file_system));
if (!*fs)
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: no memory for file system data\n");
errno = ENOMEM;
3b998: eb001d94 bl 42ff0 <__errno> <== NOT EXECUTED 3b99c: e3a0300c mov r3, #12 <== NOT EXECUTED 3b9a0: e5803000 str r3, [r0] <== NOT EXECUTED 3b9a4: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
3b9a8: eaffff67 b 3b74c <rtems_rfs_fs_open+0x108> <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
3b9ac: e5960020 ldr r0, [r6, #32] <== NOT EXECUTED 3b9b0: e3a01050 mov r1, #80 ; 0x50 <== NOT EXECUTED 3b9b4: ebff2f69 bl 7760 <calloc> <== NOT EXECUTED
if (!fs->groups)
3b9b8: e3500000 cmp r0, #0 <== NOT EXECUTED
printf ("rtems-rfs: read-superblock: invalid superblock block size%d: %s\n",
rc, strerror (rc));
return rc;
}
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
3b9bc: e586001c str r0, [r6, #28] <== NOT EXECUTED
if (!fs->groups)
3b9c0: 0a000057 beq 3bb24 <rtems_rfs_fs_open+0x4e0> <== NOT EXECUTED
/* * Perform each phase of group initialisation at the same time. This way we * know how far the initialisation has gone if an error occurs and we need to * close everything. */ for (group = 0; group < fs->group_count; group++)
3b9c4: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED 3b9c8: e3530000 cmp r3, #0 <== NOT EXECUTED 3b9cc: da000021 ble 3ba58 <rtems_rfs_fs_open+0x414> <== NOT EXECUTED
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
if (!fs->groups)
{
rtems_rfs_buffer_handle_close (fs, &handle);
3b9d0: e3a08000 mov r8, #0 <== NOT EXECUTED 3b9d4: e5962024 ldr r2, [r6, #36] ; 0x24 <== NOT EXECUTED 3b9d8: e1a04008 mov r4, r8 <== NOT EXECUTED 3b9dc: ea000006 b 3b9fc <rtems_rfs_fs_open+0x3b8> <== NOT EXECUTED
/* * Perform each phase of group initialisation at the same time. This way we * know how far the initialisation has gone if an error occurs and we need to * close everything. */ for (group = 0; group < fs->group_count; group++)
3b9e0: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED 3b9e4: e2844001 add r4, r4, #1 <== NOT EXECUTED 3b9e8: e1540003 cmp r4, r3 <== NOT EXECUTED 3b9ec: e2888050 add r8, r8, #80 ; 0x50 <== NOT EXECUTED 3b9f0: aa000018 bge 3ba58 <rtems_rfs_fs_open+0x414> <== NOT EXECUTED 3b9f4: e5962024 ldr r2, [r6, #36] ; 0x24 <== NOT EXECUTED 3b9f8: e596001c ldr r0, [r6, #28] <== NOT EXECUTED
{
rc = rtems_rfs_group_open (fs,
3b9fc: e0010294 mul r1, r4, r2 <== NOT EXECUTED 3ba00: e080c008 add ip, r0, r8 <== NOT EXECUTED 3ba04: e5963028 ldr r3, [r6, #40] ; 0x28 <== NOT EXECUTED 3ba08: e2811001 add r1, r1, #1 <== NOT EXECUTED 3ba0c: e1a00006 mov r0, r6 <== NOT EXECUTED 3ba10: e58dc000 str ip, [sp] <== NOT EXECUTED 3ba14: eb0004de bl 3cd94 <rtems_rfs_group_open> <== NOT EXECUTED
rtems_rfs_fs_block (fs, group, 0),
fs->group_blocks,
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
3ba18: e3500000 cmp r0, #0 <== NOT EXECUTED 3ba1c: daffffef ble 3b9e0 <rtems_rfs_fs_open+0x39c> <== NOT EXECUTED
{
int g;
for (g = 0; g < group; g++)
3ba20: e3540000 cmp r4, #0 <== NOT EXECUTED 3ba24: e1a0a000 mov sl, r0 <== NOT EXECUTED 3ba28: 0affffd6 beq 3b988 <rtems_rfs_fs_open+0x344> <== NOT EXECUTED 3ba2c: e3a08000 mov r8, #0 <== NOT EXECUTED 3ba30: e1a09008 mov r9, r8 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
3ba34: e596101c ldr r1, [r6, #28] <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
3ba38: e2899001 add r9, r9, #1 <== NOT EXECUTED
rtems_rfs_group_close (fs, &fs->groups[g]);
3ba3c: e0811008 add r1, r1, r8 <== NOT EXECUTED 3ba40: e1a00006 mov r0, r6 <== NOT EXECUTED 3ba44: eb0004b8 bl 3cd2c <rtems_rfs_group_close> <== NOT EXECUTED
fs->group_inodes,
&fs->groups[group]);
if (rc > 0)
{
int g;
for (g = 0; g < group; g++)
3ba48: e1540009 cmp r4, r9 <== NOT EXECUTED 3ba4c: e2888050 add r8, r8, #80 ; 0x50 <== NOT EXECUTED 3ba50: cafffff7 bgt 3ba34 <rtems_rfs_fs_open+0x3f0> <== NOT EXECUTED 3ba54: eaffffcb b 3b988 <rtems_rfs_fs_open+0x344> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
rc = rtems_rfs_inode_open (*fs, RTEMS_RFS_ROOT_INO, &inode, true);
3ba58: e3a01001 mov r1, #1 <== NOT EXECUTED 3ba5c: e28d4008 add r4, sp, #8 <== NOT EXECUTED 3ba60: e5950000 ldr r0, [r5] <== NOT EXECUTED 3ba64: e1a02004 mov r2, r4 <== NOT EXECUTED 3ba68: e1a03001 mov r3, r1 <== NOT EXECUTED 3ba6c: eb0005fc bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
3ba70: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3ba74: caffff4b bgt 3b7a8 <rtems_rfs_fs_open+0x164> <== NOT EXECUTED
rc, strerror (rc));
errno = rc;
return -1;
}
if (((*fs)->flags & RTEMS_RFS_FS_FORCE_OPEN) == 0)
3ba78: e5950000 ldr r0, [r5] <== NOT EXECUTED 3ba7c: e5903000 ldr r3, [r0] <== NOT EXECUTED 3ba80: e3130004 tst r3, #4 <== NOT EXECUTED 3ba84: 1a00000a bne 3bab4 <rtems_rfs_fs_open+0x470> <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
3ba88: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED 3ba8c: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED 3ba90: e5d31002 ldrb r1, [r3, #2] <== NOT EXECUTED
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
3ba94: e3a03801 mov r3, #65536 ; 0x10000 <== NOT EXECUTED 3ba98: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED 3ba9c: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3baa0: e1520003 cmp r2, r3 <== NOT EXECUTED 3baa4: 0a000013 beq 3baf8 <rtems_rfs_fs_open+0x4b4> <== NOT EXECUTED 3baa8: e2022a0f and r2, r2, #61440 ; 0xf000 <== NOT EXECUTED 3baac: e3520901 cmp r2, #16384 ; 0x4000 <== NOT EXECUTED 3bab0: 1a000010 bne 3baf8 <rtems_rfs_fs_open+0x4b4> <== NOT EXECUTED
errno = EIO;
return -1;
}
}
rc = rtems_rfs_inode_close (*fs, &inode);
3bab4: e1a01004 mov r1, r4 <== NOT EXECUTED 3bab8: eb0005c5 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
3babc: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3bac0: ca000004 bgt 3bad8 <rtems_rfs_fs_open+0x494> <== NOT EXECUTED
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
return -1;
}
errno = 0;
3bac4: eb001d49 bl 42ff0 <__errno> <== NOT EXECUTED 3bac8: e3a03000 mov r3, #0 <== NOT EXECUTED 3bacc: e5803000 str r3, [r0] <== NOT EXECUTED 3bad0: e1a00003 mov r0, r3 <== NOT EXECUTED
return 0;
3bad4: eaffff1c b 3b74c <rtems_rfs_fs_open+0x108> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (*fs, &inode);
if (rc > 0)
{
rtems_rfs_buffer_close (*fs);
3bad8: e5950000 ldr r0, [r5] <== NOT EXECUTED 3badc: ebfff771 bl 398a8 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
3bae0: e5950000 ldr r0, [r5] <== NOT EXECUTED 3bae4: ebff30a1 bl 7d70 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: closing root inode: %d: %s\n", rc, strerror (rc));
errno = rc;
3bae8: eb001d40 bl 42ff0 <__errno> <== NOT EXECUTED 3baec: e5804000 str r4, [r0] <== NOT EXECUTED 3baf0: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
3baf4: eaffff14 b 3b74c <rtems_rfs_fs_open+0x108> <== NOT EXECUTED
{
mode = rtems_rfs_inode_get_mode (&inode);
if ((mode == 0xffff) || !RTEMS_RFS_S_ISDIR (mode))
{
rtems_rfs_inode_close (*fs, &inode);
3baf8: e1a01004 mov r1, r4 <== NOT EXECUTED 3bafc: eb0005b4 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_buffer_close (*fs);
3bb00: e5950000 ldr r0, [r5] <== NOT EXECUTED 3bb04: ebfff767 bl 398a8 <rtems_rfs_buffer_close> <== NOT EXECUTED
free (*fs);
3bb08: e5950000 ldr r0, [r5] <== NOT EXECUTED 3bb0c: ebff3097 bl 7d70 <free> <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_OPEN))
printf ("rtems-rfs: open: invalid root inode mode\n");
errno = EIO;
3bb10: eb001d36 bl 42ff0 <__errno> <== NOT EXECUTED 3bb14: e3a03005 mov r3, #5 <== NOT EXECUTED 3bb18: e5803000 str r3, [r0] <== NOT EXECUTED 3bb1c: e3e00000 mvn r0, #0 <== NOT EXECUTED
return -1;
3bb20: eaffff09 b 3b74c <rtems_rfs_fs_open+0x108> <== NOT EXECUTED
fs->groups = calloc (fs->group_count, sizeof (rtems_rfs_group));
if (!fs->groups)
{
rtems_rfs_buffer_handle_close (fs, &handle);
3bb24: e1a00006 mov r0, r6 <== NOT EXECUTED 3bb28: e1a01007 mov r1, r7 <== NOT EXECUTED 3bb2c: ebfffebc bl 3b624 <rtems_rfs_buffer_handle_close> <== NOT EXECUTED 3bb30: e3a0a00c mov sl, #12 <== NOT EXECUTED 3bb34: eafffefd b 3b730 <rtems_rfs_fs_open+0xec> <== NOT EXECUTED
0003b588 <rtems_rfs_fs_size>:
#include <rtems/rfs/rtems-rfs-inode.h>
#include <rtems/rfs/rtems-rfs-trace.h>
uint64_t
rtems_rfs_fs_size (rtems_rfs_file_system* fs)
{
3b588: e5901008 ldr r1, [r0, #8] <== NOT EXECUTED
3b58c: e5902004 ldr r2, [r0, #4] <== NOT EXECUTED
3b590: e52d4004 push {r4} ; (str r4, [sp, #-4]!) <== NOT EXECUTED
3b594: e0843291 umull r3, r4, r1, r2 <== NOT EXECUTED
uint64_t blocks = rtems_rfs_fs_blocks (fs); uint64_t block_size = rtems_rfs_fs_block_size (fs); return blocks * block_size; }
3b598: e1a01004 mov r1, r4 <== NOT EXECUTED
3b59c: e1a00003 mov r0, r3 <== NOT EXECUTED
3b5a0: e8bd0010 pop {r4} <== NOT EXECUTED
3b5a4: e12fff1e bx lr <== NOT EXECUTED
0003cb44 <rtems_rfs_group_bitmap_alloc>:
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
3cb44: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
3cb48: e21220ff ands r2, r2, #255 ; 0xff <== NOT EXECUTED
{
size = fs->group_inodes;
3cb4c: 15905028 ldrne r5, [r0, #40] ; 0x28 <== NOT EXECUTED
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
3cb50: 05905024 ldreq r5, [r0, #36] ; 0x24 <== NOT EXECUTED
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
3cb54: e1a04001 mov r4, r1 <== NOT EXECUTED
int direction;
if (inode)
{
size = fs->group_inodes;
goal -= RTEMS_RFS_ROOT_INO;
3cb58: 12414001 subne r4, r1, #1 <== NOT EXECUTED
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
3cb5c: e24dd01c sub sp, sp, #28 <== NOT EXECUTED
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
3cb60: e1a01005 mov r1, r5 <== NOT EXECUTED
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
3cb64: e1a07000 mov r7, r0 <== NOT EXECUTED
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
3cb68: e1a00004 mov r0, r4 <== NOT EXECUTED
int
rtems_rfs_group_bitmap_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
bool inode,
rtems_rfs_bitmap_bit* result)
{
3cb6c: e58d3010 str r3, [sp, #16] <== NOT EXECUTED
rtems_rfs_bitmap_bit bit;
int offset;
bool updown;
int direction;
if (inode)
3cb70: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
3cb74: eb0078db bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (goal % size);
3cb78: e1a01005 mov r1, r5 <== NOT EXECUTED
goal -= RTEMS_RFS_ROOT_INO;
}
else
size = fs->group_blocks;
group_start = goal / size;
3cb7c: e1a0a000 mov sl, r0 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (goal % size);
3cb80: e1a00004 mov r0, r4 <== NOT EXECUTED 3cb84: eb00796b bl 5b138 <__umodsi3> <== NOT EXECUTED
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
3cb88: e28d901c add r9, sp, #28 <== NOT EXECUTED 3cb8c: e3a03000 mov r3, #0 <== NOT EXECUTED 3cb90: e5693001 strb r3, [r9, #-1]! <== NOT EXECUTED
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
if (offset)
bit = direction > 0 ? 0 : size - 1;
3cb94: e245c001 sub ip, r5, #1 <== NOT EXECUTED
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
3cb98: e1a0500a mov r5, sl <== NOT EXECUTED 3cb9c: e3a04001 mov r4, #1 <== NOT EXECUTED
/*
* If we are still looking up and down and if the group is out of range we
* have reached one end. Stopping looking up and down and just move in the
* one direction one group at a time.
*/
if ((group < 0) || (group >= fs->group_count))
3cba0: e3550000 cmp r5, #0 <== NOT EXECUTED 3cba4: e58d9008 str r9, [sp, #8] <== NOT EXECUTED
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
3cba8: e1a06003 mov r6, r3 <== NOT EXECUTED
}
else
size = fs->group_blocks;
group_start = goal / size;
bit = (rtems_rfs_bitmap_bit) (goal % size);
3cbac: e58d0014 str r0, [sp, #20] <== NOT EXECUTED
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
3cbb0: e1a08004 mov r8, r4 <== NOT EXECUTED
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
if (offset)
3cbb4: e1a0b003 mov fp, r3 <== NOT EXECUTED 3cbb8: e1a0900c mov r9, ip <== NOT EXECUTED
/*
* If we are still looking up and down and if the group is out of range we
* have reached one end. Stopping looking up and down and just move in the
* one direction one group at a time.
*/
if ((group < 0) || (group >= fs->group_count))
3cbbc: ba000002 blt 3cbcc <rtems_rfs_group_bitmap_alloc+0x88> <== NOT EXECUTED 3cbc0: e5973020 ldr r3, [r7, #32] <== NOT EXECUTED 3cbc4: e1530005 cmp r3, r5 <== NOT EXECUTED 3cbc8: ca000012 bgt 3cc18 <rtems_rfs_group_bitmap_alloc+0xd4> <== NOT EXECUTED
{
if (!updown)
3cbcc: e3580000 cmp r8, #0 <== NOT EXECUTED 3cbd0: 0a00002f beq 3cc94 <rtems_rfs_group_bitmap_alloc+0x150> <== NOT EXECUTED
break;
direction = direction > 0 ? -1 : 1;
3cbd4: e3540001 cmp r4, #1 <== NOT EXECUTED 3cbd8: 03e04000 mvneq r4, #0 <== NOT EXECUTED 3cbdc: 13a04001 movne r4, #1 <== NOT EXECUTED
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
if (offset)
3cbe0: e3560000 cmp r6, #0 <== NOT EXECUTED 3cbe4: 13a08000 movne r8, #0 <== NOT EXECUTED 3cbe8: 0a00002c beq 3cca0 <rtems_rfs_group_bitmap_alloc+0x15c> <== NOT EXECUTED
bit = direction > 0 ? 0 : size - 1;
3cbec: e3540001 cmp r4, #1 <== NOT EXECUTED 3cbf0: 11a03009 movne r3, r9 <== NOT EXECUTED 3cbf4: 03a03000 moveq r3, #0 <== NOT EXECUTED 3cbf8: e58d3014 str r3, [sp, #20] <== NOT EXECUTED
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
3cbfc: e025a694 mla r5, r4, r6, sl <== NOT EXECUTED
/*
* If we are still looking up and down and if the group is out of range we
* have reached one end. Stopping looking up and down and just move in the
* one direction one group at a time.
*/
if ((group < 0) || (group >= fs->group_count))
3cc00: e3550000 cmp r5, #0 <== NOT EXECUTED
*/
while (true)
{
rtems_rfs_bitmap_control* bitmap;
int group;
bool allocated = false;
3cc04: e5cdb01b strb fp, [sp, #27] <== NOT EXECUTED
/*
* If we are still looking up and down and if the group is out of range we
* have reached one end. Stopping looking up and down and just move in the
* one direction one group at a time.
*/
if ((group < 0) || (group >= fs->group_count))
3cc08: baffffef blt 3cbcc <rtems_rfs_group_bitmap_alloc+0x88> <== NOT EXECUTED 3cc0c: e5973020 ldr r3, [r7, #32] <== NOT EXECUTED 3cc10: e1530005 cmp r3, r5 <== NOT EXECUTED 3cc14: daffffec ble 3cbcc <rtems_rfs_group_bitmap_alloc+0x88> <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
updown = false;
continue;
}
if (inode)
3cc18: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 3cc1c: e3520000 cmp r2, #0 <== NOT EXECUTED 3cc20: 1a000020 bne 3cca8 <rtems_rfs_group_bitmap_alloc+0x164> <== NOT EXECUTED
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
3cc24: e1a02105 lsl r2, r5, #2 <== NOT EXECUTED 3cc28: e597301c ldr r3, [r7, #28] <== NOT EXECUTED 3cc2c: e58d200c str r2, [sp, #12] <== NOT EXECUTED 3cc30: e0822005 add r2, r2, r5 <== NOT EXECUTED 3cc34: e0833202 add r3, r3, r2, lsl #4 <== NOT EXECUTED 3cc38: e283c008 add ip, r3, #8 <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
3cc3c: e1a0000c mov r0, ip <== NOT EXECUTED 3cc40: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 3cc44: e59d2008 ldr r2, [sp, #8] <== NOT EXECUTED 3cc48: e28d3014 add r3, sp, #20 <== NOT EXECUTED 3cc4c: e58dc000 str ip, [sp] <== NOT EXECUTED 3cc50: eb001741 bl 4295c <rtems_rfs_bitmap_map_alloc> <== NOT EXECUTED
if (rc > 0)
3cc54: e3500000 cmp r0, #0 <== NOT EXECUTED 3cc58: e59dc000 ldr ip, [sp] <== NOT EXECUTED 3cc5c: ca00000d bgt 3cc98 <rtems_rfs_group_bitmap_alloc+0x154> <== NOT EXECUTED
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
3cc60: e5973000 ldr r3, [r7] <== NOT EXECUTED 3cc64: e3130001 tst r3, #1 <== NOT EXECUTED 3cc68: 0a000016 beq 3ccc8 <rtems_rfs_group_bitmap_alloc+0x184> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
if (allocated)
3cc6c: e5dd301b ldrb r3, [sp, #27] <== NOT EXECUTED 3cc70: e3530000 cmp r3, #0 <== NOT EXECUTED 3cc74: 1a000017 bne 3ccd8 <rtems_rfs_group_bitmap_alloc+0x194> <== NOT EXECUTED
printf ("rtems-rfs: group-bitmap-alloc: %s allocated: %" PRId32 "\n",
inode ? "inode" : "block", *result);
return 0;
}
if (updown)
3cc78: e3580000 cmp r8, #0 <== NOT EXECUTED 3cc7c: 0a000002 beq 3cc8c <rtems_rfs_group_bitmap_alloc+0x148> <== NOT EXECUTED
direction = direction > 0 ? -1 : 1;
3cc80: e3540001 cmp r4, #1 <== NOT EXECUTED 3cc84: 03e04000 mvneq r4, #0 <== NOT EXECUTED 3cc88: 13a04001 movne r4, #1 <== NOT EXECUTED
offset++;
3cc8c: e2866001 add r6, r6, #1 <== NOT EXECUTED 3cc90: eaffffd5 b 3cbec <rtems_rfs_group_bitmap_alloc+0xa8> <== NOT EXECUTED 3cc94: e3a0001c mov r0, #28 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-alloc: no blocks available\n");
return ENOSPC;
}
3cc98: e28dd01c add sp, sp, #28 <== NOT EXECUTED
3cc9c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/*
* We can start at any location and we move out from that point in each
* direction. The offset grows until we find a free bit or we hit an end.
*/
group = group_start + (direction * offset);
if (offset)
3cca0: e1a08006 mov r8, r6 <== NOT EXECUTED 3cca4: eaffffd4 b 3cbfc <rtems_rfs_group_bitmap_alloc+0xb8> <== NOT EXECUTED
updown = false;
continue;
}
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
3cca8: e1a03105 lsl r3, r5, #2 <== NOT EXECUTED 3ccac: e58d300c str r3, [sp, #12] <== NOT EXECUTED 3ccb0: e59d100c ldr r1, [sp, #12] <== NOT EXECUTED 3ccb4: e597301c ldr r3, [r7, #28] <== NOT EXECUTED 3ccb8: e0812005 add r2, r1, r5 <== NOT EXECUTED 3ccbc: e0833202 add r3, r3, r2, lsl #4 <== NOT EXECUTED 3ccc0: e283c02c add ip, r3, #44 ; 0x2c <== NOT EXECUTED 3ccc4: eaffffdc b 3cc3c <rtems_rfs_group_bitmap_alloc+0xf8> <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_alloc (bitmap, bit, &allocated, &bit);
if (rc > 0)
return rc;
if (rtems_rfs_fs_release_bitmaps (fs))
rtems_rfs_bitmap_release_buffer (fs, bitmap);
3ccc8: e59c1000 ldr r1, [ip] <== NOT EXECUTED 3cccc: e1a00007 mov r0, r7 <== NOT EXECUTED 3ccd0: ebfff315 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED 3ccd4: eaffffe4 b 3cc6c <rtems_rfs_group_bitmap_alloc+0x128> <== NOT EXECUTED
if (allocated)
{
if (inode)
3ccd8: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 3ccdc: e3530000 cmp r3, #0 <== NOT EXECUTED 3cce0: 0a000007 beq 3cd04 <rtems_rfs_group_bitmap_alloc+0x1c0> <== NOT EXECUTED
*result = rtems_rfs_group_inode (fs, group, bit);
3cce4: e59d2014 ldr r2, [sp, #20] <== NOT EXECUTED 3cce8: e5971028 ldr r1, [r7, #40] ; 0x28 <== NOT EXECUTED 3ccec: e2822001 add r2, r2, #1 <== NOT EXECUTED 3ccf0: e0232591 mla r3, r1, r5, r2 <== NOT EXECUTED 3ccf4: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 3ccf8: e3a00000 mov r0, #0 <== NOT EXECUTED 3ccfc: e5813000 str r3, [r1] <== NOT EXECUTED 3cd00: eaffffe4 b 3cc98 <rtems_rfs_group_bitmap_alloc+0x154> <== NOT EXECUTED
else
*result = rtems_rfs_group_block (&fs->groups[group], bit);
3cd04: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
3cd08: e597301c ldr r3, [r7, #28] <== NOT EXECUTED
3cd0c: e0825005 add r5, r2, r5 <== NOT EXECUTED
3cd10: e7933205 ldr r3, [r3, r5, lsl #4] <== NOT EXECUTED
3cd14: e28d1010 add r1, sp, #16 <== NOT EXECUTED
3cd18: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
3cd1c: e0823003 add r3, r2, r3 <== NOT EXECUTED
3cd20: e5813000 str r3, [r1] <== NOT EXECUTED
3cd24: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
3cd28: eaffffda b 3cc98 <rtems_rfs_group_bitmap_alloc+0x154> <== NOT EXECUTED
0003caa4 <rtems_rfs_group_bitmap_free>:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
inode ? "inode" : "block", no);
if (inode)
3caa4: e31100ff tst r1, #255 ; 0xff <== NOT EXECUTED
int
rtems_rfs_group_bitmap_free (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no)
{
3caa8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3caac: e1a04000 mov r4, r0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-free: %s free: %" PRId32 "\n",
inode ? "inode" : "block", no);
if (inode)
3cab0: 0a000015 beq 3cb0c <rtems_rfs_group_bitmap_free+0x68> <== NOT EXECUTED
{
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
3cab4: e5905028 ldr r5, [r0, #40] ; 0x28 <== NOT EXECUTED
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
3cab8: e2427001 sub r7, r2, #1 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
3cabc: e1a01005 mov r1, r5 <== NOT EXECUTED 3cac0: e1a00007 mov r0, r7 <== NOT EXECUTED 3cac4: eb00799b bl 5b138 <__umodsi3> <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
3cac8: e1a01005 mov r1, r5 <== NOT EXECUTED
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
3cacc: e1a06000 mov r6, r0 <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
3cad0: e1a00007 mov r0, r7 <== NOT EXECUTED 3cad4: eb007903 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 3cad8: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3cadc: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 3cae0: e0835200 add r5, r3, r0, lsl #4 <== NOT EXECUTED 3cae4: e285502c add r5, r5, #44 ; 0x2c <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
3cae8: e1a01006 mov r1, r6 <== NOT EXECUTED 3caec: e1a00005 mov r0, r5 <== NOT EXECUTED 3caf0: eb0016a2 bl 42580 <rtems_rfs_bitmap_map_clear> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
3caf4: e5951000 ldr r1, [r5] <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_clear (bitmap, bit);
3caf8: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
3cafc: e1a00004 mov r0, r4 <== NOT EXECUTED 3cb00: ebfff389 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return rc;
}
3cb04: e1a00006 mov r0, r6 <== NOT EXECUTED
3cb08: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
size = fs->group_inodes;
}
else
{
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
3cb0c: e5905024 ldr r5, [r0, #36] ; 0x24 <== NOT EXECUTED
}
group = no / size;
3cb10: e2427001 sub r7, r2, #1 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
3cb14: e1a01005 mov r1, r5 <== NOT EXECUTED 3cb18: e1a00007 mov r0, r7 <== NOT EXECUTED 3cb1c: eb007985 bl 5b138 <__umodsi3> <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
3cb20: e1a01005 mov r1, r5 <== NOT EXECUTED
no -= RTEMS_RFS_SUPERBLOCK_SIZE;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
3cb24: e1a06000 mov r6, r0 <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
3cb28: e1a00007 mov r0, r7 <== NOT EXECUTED 3cb2c: eb0078ed bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 3cb30: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3cb34: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 3cb38: e0835200 add r5, r3, r0, lsl #4 <== NOT EXECUTED 3cb3c: e2855008 add r5, r5, #8 <== NOT EXECUTED 3cb40: eaffffe8 b 3cae8 <rtems_rfs_group_bitmap_free+0x44> <== NOT EXECUTED
0003c9d0 <rtems_rfs_group_bitmap_test>:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
inode ? "inode" : "block", no);
if (inode)
3c9d0: e31100ff tst r1, #255 ; 0xff <== NOT EXECUTED
int
rtems_rfs_group_bitmap_test (rtems_rfs_file_system* fs,
bool inode,
rtems_rfs_bitmap_bit no,
bool* state)
{
3c9d4: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
3c9d8: e1a04000 mov r4, r0 <== NOT EXECUTED
3c9dc: e1a05002 mov r5, r2 <== NOT EXECUTED
3c9e0: e1a06003 mov r6, r3 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_BITMAPS))
printf ("rtems-rfs: group-bitmap-test: %s test: %" PRId32 "\n",
inode ? "inode" : "block", no);
if (inode)
3c9e4: 0a00001b beq 3ca58 <rtems_rfs_group_bitmap_test+0x88> <== NOT EXECUTED
{
if ((no < RTEMS_RFS_ROOT_INO) || (no > rtems_rfs_fs_inodes (fs)))
3c9e8: e3520000 cmp r2, #0 <== NOT EXECUTED 3c9ec: da000029 ble 3ca98 <rtems_rfs_group_bitmap_test+0xc8> <== NOT EXECUTED 3c9f0: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED 3c9f4: e1520003 cmp r2, r3 <== NOT EXECUTED 3c9f8: 8a000026 bhi 3ca98 <rtems_rfs_group_bitmap_test+0xc8> <== NOT EXECUTED
return EINVAL;
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
3c9fc: e5908028 ldr r8, [r0, #40] ; 0x28 <== NOT EXECUTED
if (no >= rtems_rfs_fs_blocks (fs))
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
3ca00: e2425001 sub r5, r2, #1 <== NOT EXECUTED
bit = (rtems_rfs_bitmap_bit) (no % size);
3ca04: e1a00005 mov r0, r5 <== NOT EXECUTED 3ca08: e1a01008 mov r1, r8 <== NOT EXECUTED 3ca0c: eb0079c9 bl 5b138 <__umodsi3> <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
3ca10: e1a01008 mov r1, r8 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
3ca14: e1a07000 mov r7, r0 <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
3ca18: e1a00005 mov r0, r5 <== NOT EXECUTED 3ca1c: eb007931 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 3ca20: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3ca24: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 3ca28: e0835200 add r5, r3, r0, lsl #4 <== NOT EXECUTED 3ca2c: e285502c add r5, r5, #44 ; 0x2c <== NOT EXECUTED
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
3ca30: e1a02006 mov r2, r6 <== NOT EXECUTED 3ca34: e1a01007 mov r1, r7 <== NOT EXECUTED 3ca38: e1a00005 mov r0, r5 <== NOT EXECUTED 3ca3c: eb0016b6 bl 4251c <rtems_rfs_bitmap_map_test> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
3ca40: e5951000 ldr r1, [r5] <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
3ca44: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, bitmap);
3ca48: e1a00004 mov r0, r4 <== NOT EXECUTED 3ca4c: ebfff3b6 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
return rc;
}
3ca50: e1a00006 mov r0, r6 <== NOT EXECUTED
3ca54: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
no -= RTEMS_RFS_ROOT_INO;
size = fs->group_inodes;
}
else
{
if (no >= rtems_rfs_fs_blocks (fs))
3ca58: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED 3ca5c: e1520003 cmp r2, r3 <== NOT EXECUTED 3ca60: 2a00000c bcs 3ca98 <rtems_rfs_group_bitmap_test+0xc8> <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
3ca64: e5908024 ldr r8, [r0, #36] ; 0x24 <== NOT EXECUTED
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
3ca68: e1a00002 mov r0, r2 <== NOT EXECUTED 3ca6c: e1a01008 mov r1, r8 <== NOT EXECUTED 3ca70: eb0079b0 bl 5b138 <__umodsi3> <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
3ca74: e1a01008 mov r1, r8 <== NOT EXECUTED
return EINVAL;
size = fs->group_blocks;
}
group = no / size;
bit = (rtems_rfs_bitmap_bit) (no % size);
3ca78: e1a07000 mov r7, r0 <== NOT EXECUTED
if (inode)
bitmap = &fs->groups[group].inode_bitmap;
else
bitmap = &fs->groups[group].block_bitmap;
3ca7c: e1a00005 mov r0, r5 <== NOT EXECUTED 3ca80: eb007918 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 3ca84: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3ca88: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 3ca8c: e0835200 add r5, r3, r0, lsl #4 <== NOT EXECUTED 3ca90: e2855008 add r5, r5, #8 <== NOT EXECUTED 3ca94: eaffffe5 b 3ca30 <rtems_rfs_group_bitmap_test+0x60> <== NOT EXECUTED
rc = rtems_rfs_bitmap_map_test (bitmap, bit, state);
rtems_rfs_bitmap_release_buffer (fs, bitmap);
return rc;
3ca98: e3a06016 mov r6, #22 <== NOT EXECUTED
}
3ca9c: e1a00006 mov r0, r6 <== NOT EXECUTED
3caa0: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
0003cd2c <rtems_rfs_group_close>:
return 0;
}
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
3cd2c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
3cd30: e1a05000 mov r5, r0 <== NOT EXECUTED
/* * We need to close as much as possible and also return any error if one * occurs but this may result in one even more important error being lost but * we cannot OR the errors together so this is a reasonable compromise. */ rc = rtems_rfs_bitmap_close (&group->inode_bitmap);
3cd34: e281002c add r0, r1, #44 ; 0x2c <== NOT EXECUTED
return 0;
}
int
rtems_rfs_group_close (rtems_rfs_file_system* fs, rtems_rfs_group* group)
{
3cd38: e1a04001 mov r4, r1 <== NOT EXECUTED
/* * We need to close as much as possible and also return any error if one * occurs but this may result in one even more important error being lost but * we cannot OR the errors together so this is a reasonable compromise. */ rc = rtems_rfs_bitmap_close (&group->inode_bitmap);
3cd3c: eb001547 bl 42260 <rtems_rfs_bitmap_close> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3cd40: e2841044 add r1, r4, #68 ; 0x44 <== NOT EXECUTED 3cd44: e1a07000 mov r7, r0 <== NOT EXECUTED 3cd48: e1a00005 mov r0, r5 <== NOT EXECUTED 3cd4c: ebfff2f6 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
3cd50: e3a03000 mov r3, #0 <== NOT EXECUTED
handle->bnum = 0; handle->buffer = NULL;
3cd54: e584304c str r3, [r4, #76] ; 0x4c <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3cd58: e5c43044 strb r3, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
3cd5c: e5843048 str r3, [r4, #72] ; 0x48 <== NOT EXECUTED
if (rc > 0)
result = rc;
rc = rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
if (rc > 0)
result = rc;
rc = rtems_rfs_bitmap_close (&group->block_bitmap);
3cd60: e2840008 add r0, r4, #8 <== NOT EXECUTED 3cd64: eb00153d bl 42260 <rtems_rfs_bitmap_close> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3cd68: e2841020 add r1, r4, #32 <== NOT EXECUTED
if (rc > 0)
3cd6c: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3cd70: e1a00005 mov r0, r5 <== NOT EXECUTED 3cd74: d1c76fc7 bicle r6, r7, r7, asr #31 <== NOT EXECUTED 3cd78: ebfff2eb bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
3cd7c: e3a03000 mov r3, #0 <== NOT EXECUTED
handle->bnum = 0; handle->buffer = NULL;
3cd80: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3cd84: e5c43020 strb r3, [r4, #32] <== NOT EXECUTED
handle->bnum = 0;
3cd88: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_close (fs, &group->block_bitmap_buffer);
if (rc > 0)
result = rc;
return result;
}
3cd8c: e1a00006 mov r0, r6 <== NOT EXECUTED
3cd90: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0003cd94 <rtems_rfs_group_open>:
rtems_rfs_group_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block base,
size_t size,
size_t inodes,
rtems_rfs_group* group)
{
3cd94: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3cd98: e1a06000 mov r6, r0 <== NOT EXECUTED
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
3cd9c: e5900004 ldr r0, [r0, #4] <== NOT EXECUTED
rtems_rfs_group_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block base,
size_t size,
size_t inodes,
rtems_rfs_group* group)
{
3cda0: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
3cda4: e1500001 cmp r0, r1 <== NOT EXECUTED
rtems_rfs_group_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_block base,
size_t size,
size_t inodes,
rtems_rfs_group* group)
{
3cda8: e1a0c001 mov ip, r1 <== NOT EXECUTED 3cdac: e1a07002 mov r7, r2 <== NOT EXECUTED 3cdb0: e1a09003 mov r9, r3 <== NOT EXECUTED 3cdb4: e59d402c ldr r4, [sp, #44] ; 0x2c <== NOT EXECUTED
int rc;
if (base >= rtems_rfs_fs_blocks (fs))
3cdb8: 93a0b005 movls fp, #5 <== NOT EXECUTED 3cdbc: 9a000017 bls 3ce20 <rtems_rfs_group_open+0x8c> <== NOT EXECUTED
printf ("rtems-rfs: group-open: base outside file system range: %d: %s\n",
EIO, strerror (EIO));
return EIO;
}
if ((base + size) >= rtems_rfs_fs_blocks (fs))
3cdc0: e0823001 add r3, r2, r1 <== NOT EXECUTED 3cdc4: e1500003 cmp r0, r3 <== NOT EXECUTED
size = rtems_rfs_fs_blocks (fs) - base;
3cdc8: 90617000 rsbls r7, r1, r0 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
3cdcc: e3a05000 mov r5, #0 <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,
3cdd0: e284a008 add sl, r4, #8 <== NOT EXECUTED 3cdd4: e2848020 add r8, r4, #32 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_GROUP_OPEN))
printf ("rtems-rfs: group-open: base=%" PRId32 ", blocks=%zd inodes=%zd\n",
base, size, inodes);
group->base = base;
3cdd8: e8840082 stm r4, {r1, r7} <== NOT EXECUTED
3cddc: e5c45020 strb r5, [r4, #32] <== NOT EXECUTED
handle->bnum = 0;
3cde0: e5845024 str r5, [r4, #36] ; 0x24 <== NOT EXECUTED
handle->buffer = NULL;
3cde4: e5845028 str r5, [r4, #40] ; 0x28 <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open block bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->block_bitmap, fs,
3cde8: e1a0000a mov r0, sl <== NOT EXECUTED 3cdec: e1a01006 mov r1, r6 <== NOT EXECUTED 3cdf0: e1a02008 mov r2, r8 <== NOT EXECUTED 3cdf4: e1a03007 mov r3, r7 <== NOT EXECUTED 3cdf8: e58dc000 str ip, [sp] <== NOT EXECUTED 3cdfc: eb001561 bl 42388 <rtems_rfs_bitmap_open> <== NOT EXECUTED
&group->block_bitmap_buffer, size,
group->base + RTEMS_RFS_GROUP_BLOCK_BITMAP_BLOCK);
if (rc > 0)
3ce00: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3ce04: da000008 ble 3ce2c <rtems_rfs_group_open+0x98> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3ce08: e1a00006 mov r0, r6 <== NOT EXECUTED 3ce0c: e1a01008 mov r1, r8 <== NOT EXECUTED 3ce10: ebfff2c5 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false; handle->bnum = 0; handle->buffer = NULL;
3ce14: e5845028 str r5, [r4, #40] ; 0x28 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3ce18: e5c45020 strb r5, [r4, #32] <== NOT EXECUTED
handle->bnum = 0;
3ce1c: e5845024 str r5, [r4, #36] ; 0x24 <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
}
return 0;
}
3ce20: e1a0000b mov r0, fp <== NOT EXECUTED
3ce24: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3ce28: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap handle: %d: %s\n",
rc, strerror (rc));
return rc;
}
rc = rtems_rfs_bitmap_open (&group->inode_bitmap, fs,
3ce2c: e594c000 ldr ip, [r4] <== NOT EXECUTED 3ce30: e2843044 add r3, r4, #68 ; 0x44 <== NOT EXECUTED 3ce34: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3ce38: e28cc001 add ip, ip, #1 <== NOT EXECUTED 3ce3c: e1570009 cmp r7, r9 <== NOT EXECUTED 3ce40: 31a03007 movcc r3, r7 <== NOT EXECUTED 3ce44: 21a03009 movcs r3, r9 <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
3ce48: e5c45044 strb r5, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
3ce4c: e5845048 str r5, [r4, #72] ; 0x48 <== NOT EXECUTED
handle->buffer = NULL;
3ce50: e584504c str r5, [r4, #76] ; 0x4c <== NOT EXECUTED 3ce54: e284002c add r0, r4, #44 ; 0x2c <== NOT EXECUTED 3ce58: e1a01006 mov r1, r6 <== NOT EXECUTED 3ce5c: e59d2004 ldr r2, [sp, #4] <== NOT EXECUTED 3ce60: e58dc000 str ip, [sp] <== NOT EXECUTED 3ce64: eb001547 bl 42388 <rtems_rfs_bitmap_open> <== NOT EXECUTED
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
3ce68: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3ce6c: ca00000a bgt 3ce9c <rtems_rfs_group_open+0x108> <== NOT EXECUTED
printf ("rtems-rfs: group-open: could not open inode bitmap: %d: %s\n",
rc, strerror (rc));
return rc;
}
if (rtems_rfs_fs_release_bitmaps (fs))
3ce70: e596b000 ldr fp, [r6] <== NOT EXECUTED 3ce74: e21bb001 ands fp, fp, #1 <== NOT EXECUTED 3ce78: 11a0b005 movne fp, r5 <== NOT EXECUTED 3ce7c: 1affffe7 bne 3ce20 <rtems_rfs_group_open+0x8c> <== NOT EXECUTED
{
rtems_rfs_bitmap_release_buffer (fs, &group->block_bitmap);
3ce80: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 3ce84: e1a00006 mov r0, r6 <== NOT EXECUTED 3ce88: ebfff2a7 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_bitmap_release_buffer (fs, &group->inode_bitmap);
3ce8c: e1a00006 mov r0, r6 <== NOT EXECUTED 3ce90: e594102c ldr r1, [r4, #44] ; 0x2c <== NOT EXECUTED 3ce94: ebfff2a4 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED 3ce98: eaffffe0 b 3ce20 <rtems_rfs_group_open+0x8c> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3ce9c: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 3cea0: e1a00006 mov r0, r6 <== NOT EXECUTED 3cea4: ebfff2a0 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
3cea8: e5c45044 strb r5, [r4, #68] ; 0x44 <== NOT EXECUTED
handle->bnum = 0;
3ceac: e5845048 str r5, [r4, #72] ; 0x48 <== NOT EXECUTED
handle->buffer = NULL;
3ceb0: e584504c str r5, [r4, #76] ; 0x4c <== NOT EXECUTED
&group->inode_bitmap_buffer, inodes,
group->base + RTEMS_RFS_GROUP_INODE_BITMAP_BLOCK);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &group->inode_bitmap_buffer);
rtems_rfs_bitmap_close (&group->block_bitmap);
3ceb4: e1a0000a mov r0, sl <== NOT EXECUTED 3ceb8: eb0014e8 bl 42260 <rtems_rfs_bitmap_close> <== NOT EXECUTED 3cebc: eaffffd1 b 3ce08 <rtems_rfs_group_open+0x74> <== NOT EXECUTED
0003c93c <rtems_rfs_group_usage>:
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
3c93c: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED
int
rtems_rfs_group_usage (rtems_rfs_file_system* fs,
size_t* blocks,
size_t* inodes)
{
3c940: e92d0070 push {r4, r5, r6} <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
3c944: e3530000 cmp r3, #0 <== NOT EXECUTED
size_t* blocks,
size_t* inodes)
{
int g;
*blocks = 0;
3c948: e3a04000 mov r4, #0 <== NOT EXECUTED 3c94c: e5814000 str r4, [r1] <== NOT EXECUTED
*inodes = 0;
3c950: e5824000 str r4, [r2] <== NOT EXECUTED
for (g = 0; g < fs->group_count; g++)
3c954: da000010 ble 3c99c <rtems_rfs_group_usage+0x60> <== NOT EXECUTED 3c958: e590c01c ldr ip, [r0, #28] <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
3c95c: e28c6014 add r6, ip, #20 <== NOT EXECUTED
3c960: e8960060 ldm r6, {r5, r6} <== NOT EXECUTED
3c964: e0455006 sub r5, r5, r6 <== NOT EXECUTED
3c968: e5916000 ldr r6, [r1] <== NOT EXECUTED
3c96c: e0865005 add r5, r6, r5 <== NOT EXECUTED
3c970: e5815000 str r5, [r1] <== NOT EXECUTED
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
3c974: e28c6038 add r6, ip, #56 ; 0x38 <== NOT EXECUTED
3c978: e8960060 ldm r6, {r5, r6} <== NOT EXECUTED
3c97c: e0455006 sub r5, r5, r6 <== NOT EXECUTED
3c980: e5926000 ldr r6, [r2] <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
3c984: e2844001 add r4, r4, #1 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
3c988: e0865005 add r5, r6, r5 <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
3c98c: e1540003 cmp r4, r3 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
*blocks +=
rtems_rfs_bitmap_map_size(&group->block_bitmap) -
rtems_rfs_bitmap_map_free (&group->block_bitmap);
*inodes +=
3c990: e5825000 str r5, [r2] <== NOT EXECUTED
int g;
*blocks = 0;
*inodes = 0;
for (g = 0; g < fs->group_count; g++)
3c994: e28cc050 add ip, ip, #80 ; 0x50 <== NOT EXECUTED 3c998: baffffef blt 3c95c <rtems_rfs_group_usage+0x20> <== NOT EXECUTED
*inodes +=
rtems_rfs_bitmap_map_size (&group->inode_bitmap) -
rtems_rfs_bitmap_map_free (&group->inode_bitmap);
}
if (*blocks > rtems_rfs_fs_blocks (fs))
3c99c: e5903004 ldr r3, [r0, #4] <== NOT EXECUTED 3c9a0: e591c000 ldr ip, [r1] <== NOT EXECUTED 3c9a4: e15c0003 cmp ip, r3 <== NOT EXECUTED 3c9a8: 9581c000 strls ip, [r1] <== NOT EXECUTED 3c9ac: 85813000 strhi r3, [r1] <== NOT EXECUTED
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
3c9b0: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED 3c9b4: e5921000 ldr r1, [r2] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
3c9b8: e3a00000 mov r0, #0 <== NOT EXECUTED
rtems_rfs_bitmap_map_free (&group->inode_bitmap);
}
if (*blocks > rtems_rfs_fs_blocks (fs))
*blocks = rtems_rfs_fs_blocks (fs);
if (*inodes > rtems_rfs_fs_inodes (fs))
3c9bc: e1510003 cmp r1, r3 <== NOT EXECUTED 3c9c0: 95821000 strls r1, [r2] <== NOT EXECUTED 3c9c4: 85823000 strhi r3, [r2] <== NOT EXECUTED
*inodes = rtems_rfs_fs_inodes (fs);
return 0;
}
3c9c8: e8bd0070 pop {r4, r5, r6} <== NOT EXECUTED
3c9cc: e12fff1e bx lr <== NOT EXECUTED
0003d3cc <rtems_rfs_inode_alloc>:
int
rtems_rfs_inode_alloc (rtems_rfs_file_system* fs,
rtems_rfs_bitmap_bit goal,
rtems_rfs_ino* ino)
{
3d3cc: e92d4010 push {r4, lr} <== NOT EXECUTED
3d3d0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
3d3d4: e1a04002 mov r4, r2 <== NOT EXECUTED
rtems_rfs_bitmap_bit bit; int rc; rc = rtems_rfs_group_bitmap_alloc (fs, goal, true, &bit);
3d3d8: e1a0300d mov r3, sp <== NOT EXECUTED 3d3dc: e3a02001 mov r2, #1 <== NOT EXECUTED 3d3e0: ebfffdd7 bl 3cb44 <rtems_rfs_group_bitmap_alloc> <== NOT EXECUTED
*ino = bit;
3d3e4: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3d3e8: e5843000 str r3, [r4] <== NOT EXECUTED
return rc; }
3d3ec: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3d3f0: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0003d1d4 <rtems_rfs_inode_close>:
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
3d1d4: e92d4010 push {r4, lr} <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
rc = rtems_rfs_inode_unload (fs, handle, true);
3d1d8: e3a02001 mov r2, #1 <== NOT EXECUTED
}
int
rtems_rfs_inode_close (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
3d1dc: e1a04001 mov r4, r1 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_CLOSE))
printf ("rtems-rfs: inode-close: ino: %" PRIu32 "\n", handle->ino);
rc = rtems_rfs_inode_unload (fs, handle, true);
3d1e0: ebffffd0 bl 3d128 <rtems_rfs_inode_unload> <== NOT EXECUTED
if ((rc == 0) && (handle->loads > 0))
3d1e4: e3500000 cmp r0, #0 <== NOT EXECUTED 3d1e8: 1a000002 bne 3d1f8 <rtems_rfs_inode_close+0x24> <== NOT EXECUTED 3d1ec: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 3d1f0: e3530000 cmp r3, #0 <== NOT EXECUTED 3d1f4: c3a00005 movgt r0, #5 <== NOT EXECUTED
printf ("rtems-rfs: inode-close: bad loads number: %d\n",
handle->loads);
rc = EIO;
}
handle->ino = 0;
3d1f8: e3a03000 mov r3, #0 <== NOT EXECUTED 3d1fc: e5843008 str r3, [r4, #8] <== NOT EXECUTED
return rc; }
3d200: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0003d3f4 <rtems_rfs_inode_create>:
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
3d3f4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3d3f8: e24dd05c sub sp, sp, #92 ; 0x5c <== NOT EXECUTED
3d3fc: e1dd58b0 ldrh r5, [sp, #128] ; 0x80 <== NOT EXECUTED
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
3d400: e2054a0f and r4, r5, #61440 ; 0xf000 <== NOT EXECUTED 3d404: e3540a06 cmp r4, #24576 ; 0x6000 <== NOT EXECUTED
uint16_t mode,
uint16_t links,
uid_t uid,
gid_t gid,
rtems_rfs_ino* ino)
{
3d408: e1a06000 mov r6, r0 <== NOT EXECUTED
3d40c: e1a07001 mov r7, r1 <== NOT EXECUTED
3d410: e98d000c stmib sp, {r2, r3} <== NOT EXECUTED
3d414: e1dd88b4 ldrh r8, [sp, #132] ; 0x84 <== NOT EXECUTED
3d418: e1dda8b8 ldrh sl, [sp, #136] ; 0x88 <== NOT EXECUTED
3d41c: e1dd98bc ldrh r9, [sp, #140] ; 0x8c <== NOT EXECUTED
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
3d420: 0a00000c beq 3d458 <rtems_rfs_inode_create+0x64> <== NOT EXECUTED 3d424: da000007 ble 3d448 <rtems_rfs_inode_create+0x54> <== NOT EXECUTED 3d428: e3540902 cmp r4, #32768 ; 0x8000 <== NOT EXECUTED 3d42c: 0a000009 beq 3d458 <rtems_rfs_inode_create+0x64> <== NOT EXECUTED 3d430: e3540a0a cmp r4, #40960 ; 0xa000 <== NOT EXECUTED 3d434: 0a000007 beq 3d458 <rtems_rfs_inode_create+0x64> <== NOT EXECUTED 3d438: e3a0b016 mov fp, #22 <== NOT EXECUTED
rtems_rfs_inode_free (fs, *ino);
return rc;
}
return 0;
}
3d43c: e1a0000b mov r0, fp <== NOT EXECUTED
3d440: e28dd05c add sp, sp, #92 ; 0x5c <== NOT EXECUTED
3d444: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
}
/*
* The file type is field within the mode. Check we have a sane mode set.
*/
switch (mode & RTEMS_RFS_S_IFMT)
3d448: e3540a02 cmp r4, #8192 ; 0x2000 <== NOT EXECUTED 3d44c: 0a000001 beq 3d458 <rtems_rfs_inode_create+0x64> <== NOT EXECUTED 3d450: e3540901 cmp r4, #16384 ; 0x4000 <== NOT EXECUTED 3d454: 1afffff7 bne 3d438 <rtems_rfs_inode_create+0x44> <== NOT EXECUTED
break;
default:
return EINVAL;
}
rc = rtems_rfs_inode_alloc (fs, parent, ino);
3d458: e1a00006 mov r0, r6 <== NOT EXECUTED 3d45c: e1a01007 mov r1, r7 <== NOT EXECUTED 3d460: e59d2090 ldr r2, [sp, #144] ; 0x90 <== NOT EXECUTED 3d464: ebffffd8 bl 3d3cc <rtems_rfs_inode_alloc> <== NOT EXECUTED
if (rc > 0)
3d468: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3d46c: cafffff2 bgt 3d43c <rtems_rfs_inode_create+0x48> <== NOT EXECUTED
return rc;
rc = rtems_rfs_inode_open (fs, *ino, &inode, true);
3d470: e59d3090 ldr r3, [sp, #144] ; 0x90 <== NOT EXECUTED 3d474: e1a00006 mov r0, r6 <== NOT EXECUTED 3d478: e5931000 ldr r1, [r3] <== NOT EXECUTED 3d47c: e28d200c add r2, sp, #12 <== NOT EXECUTED 3d480: e3a03001 mov r3, #1 <== NOT EXECUTED 3d484: ebffff76 bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
3d488: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3d48c: da000004 ble 3d4a4 <rtems_rfs_inode_create+0xb0> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_inode_free (fs, *ino);
3d490: e59d3090 ldr r3, [sp, #144] ; 0x90 <== NOT EXECUTED 3d494: e1a00006 mov r0, r6 <== NOT EXECUTED 3d498: e5931000 ldr r1, [r3] <== NOT EXECUTED 3d49c: ebffff9f bl 3d320 <rtems_rfs_inode_free> <== NOT EXECUTED
return rc;
3d4a0: eaffffe5 b 3d43c <rtems_rfs_inode_create+0x48> <== NOT EXECUTED
{
rtems_rfs_inode_free (fs, *ino);
return rc;
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
3d4a4: e1a01008 mov r1, r8 <== NOT EXECUTED 3d4a8: e1a02005 mov r2, r5 <== NOT EXECUTED 3d4ac: e1a0300a mov r3, sl <== NOT EXECUTED 3d4b0: e28d000c add r0, sp, #12 <== NOT EXECUTED 3d4b4: e58d9000 str r9, [sp] <== NOT EXECUTED 3d4b8: ebfffebf bl 3cfbc <rtems_rfs_inode_initialise> <== NOT EXECUTED
if (rc > 0)
3d4bc: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3d4c0: ca000010 bgt 3d508 <rtems_rfs_inode_create+0x114> <== NOT EXECUTED
/* * Only handle the specifics of a directory. Let caller handle the others. * * The inode delete will free the inode. */ if (RTEMS_RFS_S_ISDIR (mode))
3d4c4: e3540901 cmp r4, #16384 ; 0x4000 <== NOT EXECUTED 3d4c8: 0a00002d beq 3d584 <rtems_rfs_inode_create+0x190> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
3d4cc: e28d5034 add r5, sp, #52 ; 0x34 <== NOT EXECUTED 3d4d0: e1a01007 mov r1, r7 <== NOT EXECUTED 3d4d4: e1a00006 mov r0, r6 <== NOT EXECUTED 3d4d8: e1a02005 mov r2, r5 <== NOT EXECUTED 3d4dc: e3a03001 mov r3, #1 <== NOT EXECUTED 3d4e0: ebffff5f bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
3d4e4: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3d4e8: da00000e ble 3d528 <rtems_rfs_inode_create+0x134> <== NOT EXECUTED
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
3d4ec: e28d100c add r1, sp, #12 <== NOT EXECUTED 3d4f0: e1a00006 mov r0, r6 <== NOT EXECUTED 3d4f4: ebffff8c bl 3d32c <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
3d4f8: e1a00006 mov r0, r6 <== NOT EXECUTED 3d4fc: e28d100c add r1, sp, #12 <== NOT EXECUTED 3d500: ebffff33 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
3d504: eaffffcc b 3d43c <rtems_rfs_inode_create+0x48> <== NOT EXECUTED
}
rc = rtems_rfs_inode_initialise (&inode, links, mode, uid, gid);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
3d508: e28d100c add r1, sp, #12 <== NOT EXECUTED 3d50c: e1a00006 mov r0, r6 <== NOT EXECUTED 3d510: ebffff2f bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_free (fs, *ino);
3d514: e59d3090 ldr r3, [sp, #144] ; 0x90 <== NOT EXECUTED 3d518: e1a00006 mov r0, r6 <== NOT EXECUTED 3d51c: e5931000 ldr r1, [r3] <== NOT EXECUTED 3d520: ebffff7e bl 3d320 <rtems_rfs_inode_free> <== NOT EXECUTED
return rc;
3d524: eaffffc4 b 3d43c <rtems_rfs_inode_create+0x48> <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
3d528: e59d3090 ldr r3, [sp, #144] ; 0x90 <== NOT EXECUTED
3d52c: e593c000 ldr ip, [r3] <== NOT EXECUTED
3d530: e99d000c ldmib sp, {r2, r3} <== NOT EXECUTED
3d534: e1a00006 mov r0, r6 <== NOT EXECUTED
3d538: e1a01005 mov r1, r5 <== NOT EXECUTED
3d53c: e58dc000 str ip, [sp] <== NOT EXECUTED
3d540: ebfff350 bl 3a288 <rtems_rfs_dir_add_entry> <== NOT EXECUTED
if (rc > 0)
3d544: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3d548: ca00001a bgt 3d5b8 <rtems_rfs_inode_create+0x1c4> <== NOT EXECUTED
/*
* If the node is a directory update the parent link count as the
* new directory has the '..' link that points to the parent.
*/
if (RTEMS_RFS_S_ISDIR (mode))
3d54c: e3540901 cmp r4, #16384 ; 0x4000 <== NOT EXECUTED 3d550: 0a00002a beq 3d600 <rtems_rfs_inode_create+0x20c> <== NOT EXECUTED
rtems_rfs_inode_set_links (&parent_inode,
rtems_rfs_inode_get_links (&parent_inode) + 1);
rc = rtems_rfs_inode_close (fs, &parent_inode);
3d554: e1a01005 mov r1, r5 <== NOT EXECUTED 3d558: e1a00006 mov r0, r6 <== NOT EXECUTED 3d55c: ebffff1c bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
3d560: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3d564: caffffe0 bgt 3d4ec <rtems_rfs_inode_create+0xf8> <== NOT EXECUTED
rtems_rfs_inode_delete (fs, &inode);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &inode);
3d568: e28d100c add r1, sp, #12 <== NOT EXECUTED 3d56c: e1a00006 mov r0, r6 <== NOT EXECUTED 3d570: ebffff17 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
3d574: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3d578: d3a0b000 movle fp, #0 <== NOT EXECUTED 3d57c: caffffc3 bgt 3d490 <rtems_rfs_inode_create+0x9c> <== NOT EXECUTED 3d580: eaffffad b 3d43c <rtems_rfs_inode_create+0x48> <== NOT EXECUTED
*
* The inode delete will free the inode.
*/
if (RTEMS_RFS_S_ISDIR (mode))
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
3d584: e59d3090 ldr r3, [sp, #144] ; 0x90 <== NOT EXECUTED 3d588: e593c000 ldr ip, [r3] <== NOT EXECUTED 3d58c: e1a00006 mov r0, r6 <== NOT EXECUTED 3d590: e28d100c add r1, sp, #12 <== NOT EXECUTED 3d594: e59f20b4 ldr r2, [pc, #180] ; 3d650 <rtems_rfs_inode_create+0x25c><== NOT EXECUTED 3d598: e3a03001 mov r3, #1 <== NOT EXECUTED 3d59c: e58dc000 str ip, [sp] <== NOT EXECUTED 3d5a0: ebfff338 bl 3a288 <rtems_rfs_dir_add_entry> <== NOT EXECUTED
if (rc == 0)
3d5a4: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3d5a8: 0a00000c beq 3d5e0 <rtems_rfs_inode_create+0x1ec> <== NOT EXECUTED
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
if (rc > 0)
3d5ac: e35b0000 cmp fp, #0 <== NOT EXECUTED 3d5b0: daffffc5 ble 3d4cc <rtems_rfs_inode_create+0xd8> <== NOT EXECUTED 3d5b4: eaffffcc b 3d4ec <rtems_rfs_inode_create+0xf8> <== NOT EXECUTED
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, *ino);
if (rc > 0)
{
rtems_rfs_inode_delete (fs, &inode);
3d5b8: e28d100c add r1, sp, #12 <== NOT EXECUTED 3d5bc: e1a00006 mov r0, r6 <== NOT EXECUTED 3d5c0: ebffff59 bl 3d32c <rtems_rfs_inode_delete> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
3d5c4: e28d100c add r1, sp, #12 <== NOT EXECUTED 3d5c8: e1a00006 mov r0, r6 <== NOT EXECUTED 3d5cc: ebffff00 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
3d5d0: e1a00006 mov r0, r6 <== NOT EXECUTED 3d5d4: e1a01005 mov r1, r5 <== NOT EXECUTED 3d5d8: ebfffefd bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
3d5dc: eaffff96 b 3d43c <rtems_rfs_inode_create+0x48> <== NOT EXECUTED
*/
if (RTEMS_RFS_S_ISDIR (mode))
{
rc = rtems_rfs_dir_add_entry (fs, &inode, ".", 1, *ino);
if (rc == 0)
rc = rtems_rfs_dir_add_entry (fs, &inode, "..", 2, parent);
3d5e0: e1a00006 mov r0, r6 <== NOT EXECUTED 3d5e4: e28d100c add r1, sp, #12 <== NOT EXECUTED 3d5e8: e59f2064 ldr r2, [pc, #100] ; 3d654 <rtems_rfs_inode_create+0x260><== NOT EXECUTED 3d5ec: e3a03002 mov r3, #2 <== NOT EXECUTED 3d5f0: e58d7000 str r7, [sp] <== NOT EXECUTED 3d5f4: ebfff323 bl 3a288 <rtems_rfs_dir_add_entry> <== NOT EXECUTED 3d5f8: e1a0b000 mov fp, r0 <== NOT EXECUTED 3d5fc: eaffffea b 3d5ac <rtems_rfs_inode_create+0x1b8> <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
3d600: e59d3040 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED 3d604: e5d30000 ldrb r0, [r3] <== NOT EXECUTED 3d608: e5d31001 ldrb r1, [r3, #1] <== NOT EXECUTED
if (links == 0xffff)
3d60c: e3a02801 mov r2, #65536 ; 0x10000 <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
3d610: e1811400 orr r1, r1, r0, lsl #8 <== NOT EXECUTED
if (links == 0xffff)
3d614: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3d618: e1510002 cmp r1, r2 <== NOT EXECUTED 3d61c: 12811001 addne r1, r1, #1 <== NOT EXECUTED 3d620: 11a01801 lslne r1, r1, #16 <== NOT EXECUTED 3d624: 11a02821 lsrne r2, r1, #16 <== NOT EXECUTED 3d628: 03a01000 moveq r1, #0 <== NOT EXECUTED 3d62c: 11a01c21 lsrne r1, r1, #24 <== NOT EXECUTED
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
3d630: e5c31000 strb r1, [r3] <== NOT EXECUTED 3d634: e59d3040 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
if (links == 0xffff)
3d638: 03a02001 moveq r2, #1 <== NOT EXECUTED 3d63c: 120220ff andne r2, r2, #255 ; 0xff <== NOT EXECUTED
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
3d640: e5c32001 strb r2, [r3, #1] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3d644: e3a03001 mov r3, #1 <== NOT EXECUTED 3d648: e5cd3044 strb r3, [sp, #68] ; 0x44 <== NOT EXECUTED 3d64c: eaffffc0 b 3d554 <rtems_rfs_inode_create+0x160> <== NOT EXECUTED
0003d32c <rtems_rfs_inode_delete>:
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
3d32c: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
3d330: e591300c ldr r3, [r1, #12] <== NOT EXECUTED 3d334: e3530000 cmp r3, #0 <== NOT EXECUTED
}
int
rtems_rfs_inode_delete (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
3d338: e1a05000 mov r5, r0 <== NOT EXECUTED 3d33c: e24dd050 sub sp, sp, #80 ; 0x50 <== NOT EXECUTED 3d340: e1a04001 mov r4, r1 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_DELETE))
printf("rtems-rfs: inode-delete: ino:%" PRIu32 " loaded:%s\n",
rtems_rfs_inode_ino (handle),
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
3d344: 01a00003 moveq r0, r3 <== NOT EXECUTED 3d348: 0a000003 beq 3d35c <rtems_rfs_inode_delete+0x30> <== NOT EXECUTED
rtems_rfs_block_map map;
/*
* Free the ino number.
*/
rc = rtems_rfs_inode_free (fs, handle->ino);
3d34c: e5911008 ldr r1, [r1, #8] <== NOT EXECUTED 3d350: ebfffff2 bl 3d320 <rtems_rfs_inode_free> <== NOT EXECUTED
if (rc > 0)
3d354: e3500000 cmp r0, #0 <== NOT EXECUTED 3d358: da000001 ble 3d364 <rtems_rfs_inode_delete+0x38> <== NOT EXECUTED
handle->loads = 0;
handle->node = NULL;
}
}
return rc;
}
3d35c: e28dd050 add sp, sp, #80 ; 0x50 <== NOT EXECUTED
3d360: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
3d364: e1a00005 mov r0, r5 <== NOT EXECUTED 3d368: e1a01004 mov r1, r4 <== NOT EXECUTED 3d36c: e1a0200d mov r2, sp <== NOT EXECUTED 3d370: ebfff0a2 bl 39600 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc == 0)
3d374: e3500000 cmp r0, #0 <== NOT EXECUTED
return rc;
/*
* Free the blocks the inode may have attached.
*/
rc = rtems_rfs_block_map_open (fs, handle, &map);
3d378: e1a0600d mov r6, sp <== NOT EXECUTED
if (rc == 0)
3d37c: 1afffff6 bne 3d35c <rtems_rfs_inode_delete+0x30> <== NOT EXECUTED
{
int rrc;
rrc = rtems_rfs_block_map_free_all (fs, &map);
3d380: e1a0100d mov r1, sp <== NOT EXECUTED 3d384: e1a00005 mov r0, r5 <== NOT EXECUTED 3d388: ebffeee2 bl 38f18 <rtems_rfs_block_map_free_all> <== NOT EXECUTED
rc = rtems_rfs_block_map_close (fs, &map);
3d38c: e1a0100d mov r1, sp <== NOT EXECUTED 3d390: e1a00005 mov r0, r5 <== NOT EXECUTED 3d394: ebfff026 bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
rrc = rc;
memset (handle->node, 0xff, RTEMS_RFS_INODE_SIZE);
3d398: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED 3d39c: e3a02038 mov r2, #56 ; 0x38 <== NOT EXECUTED 3d3a0: e594000c ldr r0, [r4, #12] <== NOT EXECUTED 3d3a4: eb002448 bl 464cc <memset> <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3d3a8: e3a03001 mov r3, #1 <== NOT EXECUTED 3d3ac: e1a01004 mov r1, r4 <== NOT EXECUTED 3d3b0: e5e13010 strb r3, [r1, #16]! <== NOT EXECUTED
/*
* Do the release here to avoid the ctime field being set on a
* close. Also if there loads is greater then one then other loads
* active. Forcing the loads count to 0.
*/
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
3d3b4: e1a00005 mov r0, r5 <== NOT EXECUTED 3d3b8: ebfff15b bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->loads = 0;
3d3bc: e3a03000 mov r3, #0 <== NOT EXECUTED
handle->node = NULL;
3d3c0: e584300c str r3, [r4, #12] <== NOT EXECUTED
* Do the release here to avoid the ctime field being set on a
* close. Also if there loads is greater then one then other loads
* active. Forcing the loads count to 0.
*/
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
handle->loads = 0;
3d3c4: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED 3d3c8: eaffffe3 b 3d35c <rtems_rfs_inode_delete+0x30> <== NOT EXECUTED
0003d320 <rtems_rfs_inode_free>:
}
int
rtems_rfs_inode_free (rtems_rfs_file_system* fs,
rtems_rfs_ino ino)
{
3d320: e1a02001 mov r2, r1 <== NOT EXECUTED
rtems_rfs_bitmap_bit bit; bit = ino; return rtems_rfs_group_bitmap_free (fs, true, bit);
3d324: e3a01001 mov r1, #1 <== NOT EXECUTED 3d328: eafffddd b 3caa4 <rtems_rfs_group_bitmap_free> <== NOT EXECUTED
0003cec0 <rtems_rfs_inode_get_size>:
}
rtems_rfs_pos
rtems_rfs_inode_get_size (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
3cec0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
3cec4: e591200c ldr r2, [r1, #12] <== NOT EXECUTED 3cec8: e282300c add r3, r2, #12 <== NOT EXECUTED
rtems_rfs_block_size size; size.count = rtems_rfs_inode_get_block_count (handle);
3cecc: e5d31003 ldrb r1, [r3, #3] <== NOT EXECUTED 3ced0: e5d2c00c ldrb ip, [r2, #12] <== NOT EXECUTED 3ced4: e5d3e001 ldrb lr, [r3, #1] <== NOT EXECUTED 3ced8: e181cc0c orr ip, r1, ip, lsl #24 <== NOT EXECUTED 3cedc: e5d31002 ldrb r1, [r3, #2] <== NOT EXECUTED 3cee0: e18c380e orr r3, ip, lr, lsl #16 <== NOT EXECUTED
}
rtems_rfs_pos
rtems_rfs_inode_get_size (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
3cee4: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
rtems_rfs_block_size size; size.count = rtems_rfs_inode_get_block_count (handle);
3cee8: e1833401 orr r3, r3, r1, lsl #8 <== NOT EXECUTED 3ceec: e58d3000 str r3, [sp] <== NOT EXECUTED
size.offset = rtems_rfs_inode_get_block_offset (handle);
3cef0: e5d2300b ldrb r3, [r2, #11] <== NOT EXECUTED 3cef4: e5d2200a ldrb r2, [r2, #10] <== NOT EXECUTED
return rtems_rfs_block_get_size (fs, &size);
3cef8: e1a0100d mov r1, sp <== NOT EXECUTED
rtems_rfs_inode_get_size (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
rtems_rfs_block_size size;
size.count = rtems_rfs_inode_get_block_count (handle);
size.offset = rtems_rfs_inode_get_block_offset (handle);
3cefc: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED 3cf00: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
return rtems_rfs_block_get_size (fs, &size);
3cf04: ebffee6c bl 388bc <rtems_rfs_block_get_size> <== NOT EXECUTED
}
3cf08: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3cf0c: e8bd8000 pop {pc} <== NOT EXECUTED
0003cfbc <rtems_rfs_inode_initialise>:
rtems_rfs_inode_initialise (rtems_rfs_inode_handle* handle,
uint16_t links,
uint16_t mode,
uid_t uid,
gid_t gid)
{
3cfbc: e92d0030 push {r4, r5} <== NOT EXECUTED
3cfc0: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
3cfc4: e590400c ldr r4, [r0, #12] <== NOT EXECUTED 3cfc8: e1a05c21 lsr r5, r1, #24 <== NOT EXECUTED 3cfcc: e1a0c000 mov ip, r0 <== NOT EXECUTED 3cfd0: e1dd00b8 ldrh r0, [sp, #8] <== NOT EXECUTED 3cfd4: e5c45000 strb r5, [r4] <== NOT EXECUTED 3cfd8: e59c400c ldr r4, [ip, #12] <== NOT EXECUTED 3cfdc: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 3cfe0: e5c41001 strb r1, [r4, #1] <== NOT EXECUTED
* @prarm flags The flags.
*/
static inline void
rtems_rfs_inode_set_flags (rtems_rfs_inode_handle* handle, uint16_t flags)
{
rtems_rfs_write_u16 (&handle->node->flags, flags);
3cfe4: e59c400c ldr r4, [ip, #12] <== NOT EXECUTED 3cfe8: e3a01000 mov r1, #0 <== NOT EXECUTED 3cfec: e5c41008 strb r1, [r4, #8] <== NOT EXECUTED 3cff0: e59c400c ldr r4, [ip, #12] <== NOT EXECUTED 3cff4: e5c41009 strb r1, [r4, #9] <== NOT EXECUTED 3cff8: e1a02802 lsl r2, r2, #16 <== NOT EXECUTED
* @prarm mode The mode.
*/
static inline void
rtems_rfs_inode_set_mode (rtems_rfs_inode_handle* handle, uint16_t mode)
{
rtems_rfs_write_u16 (&handle->node->mode, mode);
3cffc: e59c400c ldr r4, [ip, #12] <== NOT EXECUTED 3d000: e1a05c22 lsr r5, r2, #24 <== NOT EXECUTED 3d004: e5c45002 strb r5, [r4, #2] <== NOT EXECUTED 3d008: e59c400c ldr r4, [ip, #12] <== NOT EXECUTED 3d00c: e1a02822 lsr r2, r2, #16 <== NOT EXECUTED 3d010: e5c42003 strb r2, [r4, #3] <== NOT EXECUTED 3d014: e1a03803 lsl r3, r3, #16 <== NOT EXECUTED 3d018: e1a03823 lsr r3, r3, #16 <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_uid_gid (rtems_rfs_inode_handle* handle,
uint16_t uid, uint16_t gid)
{
rtems_rfs_write_u32 (&handle->node->owner, (((uint32_t) gid) << 16) | uid);
3d01c: e59c200c ldr r2, [ip, #12] <== NOT EXECUTED 3d020: e1830800 orr r0, r3, r0, lsl #16 <== NOT EXECUTED 3d024: e1a04c20 lsr r4, r0, #24 <== NOT EXECUTED 3d028: e5c24004 strb r4, [r2, #4] <== NOT EXECUTED 3d02c: e59c200c ldr r2, [ip, #12] <== NOT EXECUTED 3d030: e1a04820 lsr r4, r0, #16 <== NOT EXECUTED 3d034: e5c24005 strb r4, [r2, #5] <== NOT EXECUTED 3d038: e59c200c ldr r2, [ip, #12] <== NOT EXECUTED 3d03c: e1a00420 lsr r0, r0, #8 <== NOT EXECUTED 3d040: e5c20006 strb r0, [r2, #6] <== NOT EXECUTED 3d044: e59c200c ldr r2, [ip, #12] <== NOT EXECUTED 3d048: e5c23007 strb r3, [r2, #7] <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
3d04c: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED 3d050: e5c3100a strb r1, [r3, #10] <== NOT EXECUTED 3d054: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED 3d058: e5c3100b strb r1, [r3, #11] <== NOT EXECUTED
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
3d05c: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED 3d060: e5c3100c strb r1, [r3, #12] <== NOT EXECUTED 3d064: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED 3d068: e5c3100d strb r1, [r3, #13] <== NOT EXECUTED 3d06c: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED 3d070: e5c3100e strb r1, [r3, #14] <== NOT EXECUTED 3d074: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3d078: e3a04001 mov r4, #1 <== NOT EXECUTED
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
3d07c: e5c3100f strb r1, [r3, #15] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3d080: e5cc4010 strb r4, [ip, #16] <== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
3d084: e1a00001 mov r0, r1 <== NOT EXECUTED 3d088: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED 3d08c: e0833001 add r3, r3, r1 <== NOT EXECUTED 3d090: e5c3001c strb r0, [r3, #28] <== NOT EXECUTED 3d094: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED 3d098: e3a02000 mov r2, #0 <== NOT EXECUTED 3d09c: e0833001 add r3, r3, r1 <== NOT EXECUTED 3d0a0: e5c3201d strb r2, [r3, #29] <== NOT EXECUTED 3d0a4: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED 3d0a8: e0833001 add r3, r3, r1 <== NOT EXECUTED 3d0ac: e5c3001e strb r0, [r3, #30] <== NOT EXECUTED 3d0b0: e59c300c ldr r3, [ip, #12] <== NOT EXECUTED 3d0b4: e0833001 add r3, r3, r1 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3d0b8: e2811004 add r1, r1, #4 <== NOT EXECUTED
rtems_rfs_inode_set_flags (handle, 0); rtems_rfs_inode_set_mode (handle, mode); rtems_rfs_inode_set_uid_gid (handle, uid, gid); rtems_rfs_inode_set_block_offset (handle, 0); rtems_rfs_inode_set_block_count (handle, 0); for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
3d0bc: e3510014 cmp r1, #20 <== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
3d0c0: e5c3001f strb r0, [r3, #31] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3d0c4: e5cc4010 strb r4, [ip, #16] <== NOT EXECUTED 3d0c8: e3a03001 mov r3, #1 <== NOT EXECUTED 3d0cc: 1affffed bne 3d088 <rtems_rfs_inode_initialise+0xcc> <== NOT EXECUTED
* @param block_count The last map block number.
*/
static inline void
rtems_rfs_inode_set_last_map_block (rtems_rfs_inode_handle* handle, uint32_t last_map_block)
{
rtems_rfs_write_u32 (&handle->node->last_map_block, last_map_block);
3d0d0: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED 3d0d4: e5c12030 strb r2, [r1, #48] ; 0x30 <== NOT EXECUTED 3d0d8: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED 3d0dc: e5c12031 strb r2, [r1, #49] ; 0x31 <== NOT EXECUTED 3d0e0: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED 3d0e4: e5c12032 strb r2, [r1, #50] ; 0x32 <== NOT EXECUTED 3d0e8: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED 3d0ec: e5c12033 strb r2, [r1, #51] ; 0x33 <== NOT EXECUTED
* @param block_count The last data block number.
*/
static inline void
rtems_rfs_inode_set_last_data_block (rtems_rfs_inode_handle* handle, uint32_t last_data_block)
{
rtems_rfs_write_u32 (&handle->node->last_data_block, last_data_block);
3d0f0: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED 3d0f4: e5c12034 strb r2, [r1, #52] ; 0x34 <== NOT EXECUTED 3d0f8: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED 3d0fc: e5c12035 strb r2, [r1, #53] ; 0x35 <== NOT EXECUTED 3d100: e59c100c ldr r1, [ip, #12] <== NOT EXECUTED 3d104: e5c12036 strb r2, [r1, #54] ; 0x36 <== NOT EXECUTED 3d108: e59c000c ldr r0, [ip, #12] <== NOT EXECUTED
rtems_rfs_inode_set_block (handle, b, 0);
rtems_rfs_inode_set_last_map_block (handle, 0);
rtems_rfs_inode_set_last_data_block (handle, 0);
return rtems_rfs_inode_time_stamp_now (handle, true, true);
3d10c: e1a01003 mov r1, r3 <== NOT EXECUTED 3d110: e5c02037 strb r2, [r0, #55] ; 0x37 <== NOT EXECUTED 3d114: e1a0000c mov r0, ip <== NOT EXECUTED 3d118: e1a02003 mov r2, r3 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3d11c: e5cc3010 strb r3, [ip, #16] <== NOT EXECUTED
}
3d120: e8bd0030 pop {r4, r5} <== NOT EXECUTED
rtems_rfs_inode_set_block_count (handle, 0);
for (b = 0; b < RTEMS_RFS_INODE_BLOCKS; b++)
rtems_rfs_inode_set_block (handle, b, 0);
rtems_rfs_inode_set_last_map_block (handle, 0);
rtems_rfs_inode_set_last_data_block (handle, 0);
return rtems_rfs_inode_time_stamp_now (handle, true, true);
3d124: eaffff79 b 3cf10 <rtems_rfs_inode_time_stamp_now> <== NOT EXECUTED
0003d204 <rtems_rfs_inode_load>:
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
3d204: e591300c ldr r3, [r1, #12] <== NOT EXECUTED 3d208: e3530000 cmp r3, #0 <== NOT EXECUTED
}
int
rtems_rfs_inode_load (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle)
{
3d20c: e92d4010 push {r4, lr} <== NOT EXECUTED
3d210: e1a04001 mov r4, r1 <== NOT EXECUTED
/*
* An inode does not move so once loaded no need to do again.
*/
if (!rtems_rfs_inode_is_loaded (handle))
3d214: 0a000004 beq 3d22c <rtems_rfs_inode_load+0x28> <== NOT EXECUTED
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
}
handle->loads++;
3d218: e5943024 ldr r3, [r4, #36] ; 0x24 <== NOT EXECUTED 3d21c: e2833001 add r3, r3, #1 <== NOT EXECUTED 3d220: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED 3d224: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
}
3d228: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if (!rtems_rfs_inode_is_loaded (handle))
{
int rc;
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
3d22c: e2811010 add r1, r1, #16 <== NOT EXECUTED 3d230: e594201c ldr r2, [r4, #28] <== NOT EXECUTED 3d234: e3a03001 mov r3, #1 <== NOT EXECUTED 3d238: ebfff205 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
handle->block, true);
if (rc > 0)
3d23c: e3500000 cmp r0, #0 <== NOT EXECUTED
3d240: c8bd8010 popgt {r4, pc} <== NOT EXECUTED
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
handle->node += handle->offset;
3d244: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
handle->block, true);
if (rc > 0)
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
3d248: e5942018 ldr r2, [r4, #24] <== NOT EXECUTED
handle->node += handle->offset;
3d24c: e1a01303 lsl r1, r3, #6 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs,&handle->buffer,
handle->block, true);
if (rc > 0)
return rc;
handle->node = rtems_rfs_buffer_data (&handle->buffer);
3d250: e5922020 ldr r2, [r2, #32] <== NOT EXECUTED
handle->node += handle->offset;
3d254: e0413183 sub r3, r1, r3, lsl #3 <== NOT EXECUTED 3d258: e0823003 add r3, r2, r3 <== NOT EXECUTED 3d25c: e584300c str r3, [r4, #12] <== NOT EXECUTED 3d260: eaffffec b 3d218 <rtems_rfs_inode_load+0x14> <== NOT EXECUTED
0003d264 <rtems_rfs_inode_open>:
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
if (ino == RTEMS_RFS_EMPTY_INO)
3d264: e3510000 cmp r1, #0 <== NOT EXECUTED
int
rtems_rfs_inode_open (rtems_rfs_file_system* fs,
rtems_rfs_ino ino,
rtems_rfs_inode_handle* handle,
bool load)
{
3d268: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3d26c: e1a04000 mov r4, r0 <== NOT EXECUTED
3d270: e1a05002 mov r5, r2 <== NOT EXECUTED
3d274: e20380ff and r8, r3, #255 ; 0xff <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_OPEN))
printf ("rtems-rfs: inode-open: ino: %" PRIu32 "\n", ino);
if (ino == RTEMS_RFS_EMPTY_INO)
3d278: 0a000026 beq 3d318 <rtems_rfs_inode_open+0xb4> <== NOT EXECUTED
return EINVAL;
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
3d27c: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED 3d280: e2417001 sub r7, r1, #1 <== NOT EXECUTED 3d284: e1570003 cmp r7, r3 <== NOT EXECUTED 3d288: 8a000022 bhi 3d318 <rtems_rfs_inode_open+0xb4> <== NOT EXECUTED
return EINVAL;
handle->ino = ino;
3d28c: e5821008 str r1, [r2, #8] <== NOT EXECUTED
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
3d290: e5909028 ldr r9, [r0, #40] ; 0x28 <== NOT EXECUTED
if ((ino - RTEMS_RFS_ROOT_INO) > rtems_rfs_fs_inodes (fs))
return EINVAL;
handle->ino = ino;
handle->node = NULL;
3d294: e3a06000 mov r6, #0 <== NOT EXECUTED 3d298: e582600c str r6, [r2, #12] <== NOT EXECUTED
handle->loads = 0;
3d29c: e5826024 str r6, [r2, #36] ; 0x24 <== NOT EXECUTED
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
3d2a0: e1a01009 mov r1, r9 <== NOT EXECUTED 3d2a4: e1a00007 mov r0, r7 <== NOT EXECUTED 3d2a8: eb0077a2 bl 5b138 <__umodsi3> <== NOT EXECUTED
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
3d2ac: e594a02c ldr sl, [r4, #44] ; 0x2c <== NOT EXECUTED
handle->offset = gino % fs->inodes_per_block;
3d2b0: e1a0100a mov r1, sl <== NOT EXECUTED
handle->node = NULL;
handle->loads = 0;
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
3d2b4: e1a0b000 mov fp, r0 <== NOT EXECUTED
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
3d2b8: eb00779e bl 5b138 <__umodsi3> <== NOT EXECUTED
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
3d2bc: e1a01009 mov r1, r9 <== NOT EXECUTED
gino = ino - RTEMS_RFS_ROOT_INO;
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
3d2c0: e5850020 str r0, [r5, #32] <== NOT EXECUTED
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
3d2c4: e1a00007 mov r0, r7 <== NOT EXECUTED 3d2c8: eb007706 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 3d2cc: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3d2d0: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 3d2d4: e7937200 ldr r7, [r3, r0, lsl #4] <== NOT EXECUTED 3d2d8: e1a0100a mov r1, sl <== NOT EXECUTED 3d2dc: e1a0000b mov r0, fp <== NOT EXECUTED 3d2e0: eb007700 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 3d2e4: e2877002 add r7, r7, #2 <== NOT EXECUTED 3d2e8: e0870000 add r0, r7, r0 <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
3d2ec: e1580006 cmp r8, r6 <== NOT EXECUTED
group = gino / fs->group_inodes;
gino = gino % fs->group_inodes;
index = (gino / fs->inodes_per_block) + RTEMS_RFS_GROUP_INODE_BLOCK;
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
3d2f0: e585001c str r0, [r5, #28] <== NOT EXECUTED
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
handle->bnum = 0;
handle->buffer = NULL;
3d2f4: e5856018 str r6, [r5, #24] <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
3d2f8: e5c56010 strb r6, [r5, #16] <== NOT EXECUTED
handle->bnum = 0;
3d2fc: e5856014 str r6, [r5, #20] <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
3d300: 01a00008 moveq r0, r8 <== NOT EXECUTED
3d304: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
rc = rtems_rfs_inode_load (fs, handle);
3d308: e1a00004 mov r0, r4 <== NOT EXECUTED 3d30c: e1a01005 mov r1, r5 <== NOT EXECUTED
return rc; }
3d310: e8bd4ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
handle->offset = gino % fs->inodes_per_block;
handle->block = rtems_rfs_group_block (&fs->groups[group], index);
rc = rtems_rfs_buffer_handle_open (fs, &handle->buffer);
if ((rc == 0) && load)
rc = rtems_rfs_inode_load (fs, handle);
3d314: eaffffba b 3d204 <rtems_rfs_inode_load> <== NOT EXECUTED 3d318: e3a00016 mov r0, #22 <== NOT EXECUTED
return rc; }
3d31c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
0003bb5c <rtems_rfs_inode_overhead>:
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
3bb5c: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
/**
* Return the inode overhead given a number of inodes.
*/
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
3bb60: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3bb64: e1a04000 mov r4, r0 <== NOT EXECUTED
int blocks; int bits_per_block; blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
3bb68: e1a00303 lsl r0, r3, #6 <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
3bb6c: e0500183 subs r0, r0, r3, lsl #3 <== NOT EXECUTED
static int
rtems_rfs_inode_overhead (rtems_rfs_file_system* fs)
{
int blocks;
int bits_per_block;
blocks = rtems_rfs_rup_quotient(fs->group_inodes * RTEMS_RFS_INODE_SIZE,
3bb70: e5945008 ldr r5, [r4, #8] <== NOT EXECUTED
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
3bb74: 03a00e7d moveq r0, #2000 ; 0x7d0 <== NOT EXECUTED 3bb78: 0a000007 beq 3bb9c <rtems_rfs_inode_overhead+0x40> <== NOT EXECUTED 3bb7c: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3bb80: e1a01005 mov r1, r5 <== NOT EXECUTED 3bb84: eb007cd7 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 3bb88: e2800002 add r0, r0, #2 <== NOT EXECUTED 3bb8c: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 3bb90: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 3bb94: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 3bb98: e1a00180 lsl r0, r0, #3 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
3bb9c: e5943004 ldr r3, [r4, #4] <== NOT EXECUTED
* Return the number of bits that fit in the block size.
*/
static int
rtems_rfs_bits_per_block (rtems_rfs_file_system* fs)
{
return rtems_rfs_bitmap_numof_bits (rtems_rfs_fs_block_size (fs));
3bba0: e1a01185 lsl r1, r5, #3 <== NOT EXECUTED
rtems_rfs_fs_block_size (fs));
bits_per_block = rtems_rfs_bits_per_block (fs);
/*
* There could be more bits than blocks, eg 512K disk with 512 blocks.
*/
if (bits_per_block > (rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE))
3bba4: e2433001 sub r3, r3, #1 <== NOT EXECUTED
bits_per_block = rtems_rfs_fs_blocks (fs) - RTEMS_RFS_SUPERBLOCK_SIZE;
3bba8: e1510003 cmp r1, r3 <== NOT EXECUTED 3bbac: 21a01003 movcs r1, r3 <== NOT EXECUTED 3bbb0: eb007d10 bl 5aff8 <__aeabi_idiv> <== NOT EXECUTED
return ((blocks + 1) * 100 * 10) / bits_per_block; }
3bbb4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
0003cf10 <rtems_rfs_inode_time_stamp_now>:
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
time_t now;
if (!rtems_rfs_inode_is_loaded (handle))
3cf10: e590300c ldr r3, [r0, #12] <== NOT EXECUTED 3cf14: e3530000 cmp r3, #0 <== NOT EXECUTED
int
rtems_rfs_inode_time_stamp_now (rtems_rfs_inode_handle* handle,
bool atime,
bool mtime)
{
3cf18: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
3cf1c: e1a04000 mov r4, r0 <== NOT EXECUTED
3cf20: e20160ff and r6, r1, #255 ; 0xff <== NOT EXECUTED
3cf24: e20250ff and r5, r2, #255 ; 0xff <== NOT EXECUTED
time_t now; if (!rtems_rfs_inode_is_loaded (handle))
3cf28: 03a00006 moveq r0, #6 <== NOT EXECUTED
3cf2c: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
return ENXIO;
now = time (NULL);
3cf30: e3a00000 mov r0, #0 <== NOT EXECUTED 3cf34: eb00479f bl 4edb8 <time> <== NOT EXECUTED
if (atime)
3cf38: e3560000 cmp r6, #0 <== NOT EXECUTED 3cf3c: 0a00000c beq 3cf74 <rtems_rfs_inode_time_stamp_now+0x64> <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
3cf40: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3cf44: e1a02c20 lsr r2, r0, #24 <== NOT EXECUTED 3cf48: e5c32010 strb r2, [r3, #16] <== NOT EXECUTED 3cf4c: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3cf50: e1a02820 lsr r2, r0, #16 <== NOT EXECUTED 3cf54: e5c32011 strb r2, [r3, #17] <== NOT EXECUTED 3cf58: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3cf5c: e1a02420 lsr r2, r0, #8 <== NOT EXECUTED 3cf60: e5c32012 strb r2, [r3, #18] <== NOT EXECUTED 3cf64: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3cf68: e5c30013 strb r0, [r3, #19] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3cf6c: e3a03001 mov r3, #1 <== NOT EXECUTED 3cf70: e5c43010 strb r3, [r4, #16] <== NOT EXECUTED
rtems_rfs_inode_set_atime (handle, now);
if (mtime)
3cf74: e3550000 cmp r5, #0 <== NOT EXECUTED
3cf78: 01a00005 moveq r0, r5 <== NOT EXECUTED
3cf7c: 08bd8070 popeq {r4, r5, r6, pc} <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
3cf80: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3cf84: e1a02c20 lsr r2, r0, #24 <== NOT EXECUTED 3cf88: e5c32014 strb r2, [r3, #20] <== NOT EXECUTED 3cf8c: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3cf90: e1a02820 lsr r2, r0, #16 <== NOT EXECUTED 3cf94: e5c32015 strb r2, [r3, #21] <== NOT EXECUTED 3cf98: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3cf9c: e1a02420 lsr r2, r0, #8 <== NOT EXECUTED 3cfa0: e5c32016 strb r2, [r3, #22] <== NOT EXECUTED 3cfa4: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3cfa8: e5c30017 strb r0, [r3, #23] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3cfac: e3a03001 mov r3, #1 <== NOT EXECUTED 3cfb0: e5c43010 strb r3, [r4, #16] <== NOT EXECUTED 3cfb4: e3a00000 mov r0, #0 <== NOT EXECUTED
rtems_rfs_inode_set_mtime (handle, now);
return 0;
}
3cfb8: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0003d128 <rtems_rfs_inode_unload>:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
3d128: e591300c ldr r3, [r1, #12] <== NOT EXECUTED 3d12c: e3530000 cmp r3, #0 <== NOT EXECUTED
int
rtems_rfs_inode_unload (rtems_rfs_file_system* fs,
rtems_rfs_inode_handle* handle,
bool update_ctime)
{
3d130: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3d134: e20220ff and r2, r2, #255 ; 0xff <== NOT EXECUTED
3d138: e1a04001 mov r4, r1 <== NOT EXECUTED
3d13c: e1a05000 mov r5, r0 <== NOT EXECUTED
if (rtems_rfs_trace (RTEMS_RFS_TRACE_INODE_UNLOAD))
printf ("rtems-rfs: inode-unload: ino=%" PRIu32 " loads=%i loaded=%s\n",
handle->ino, handle->loads,
rtems_rfs_inode_is_loaded (handle) ? "yes" : "no");
if (rtems_rfs_inode_is_loaded (handle))
3d140: 0a000012 beq 3d190 <rtems_rfs_inode_unload+0x68> <== NOT EXECUTED
{
if (handle->loads == 0)
3d144: e5910024 ldr r0, [r1, #36] ; 0x24 <== NOT EXECUTED
3d148: e3500000 cmp r0, #0 <== NOT EXECUTED
3d14c: 03a00005 moveq r0, #5 <== NOT EXECUTED
3d150: 08bd8030 popeq {r4, r5, pc} <== NOT EXECUTED
return EIO;
handle->loads--;
3d154: e2400001 sub r0, r0, #1 <== NOT EXECUTED
if (handle->loads == 0)
3d158: e3500000 cmp r0, #0 <== NOT EXECUTED
if (rtems_rfs_inode_is_loaded (handle))
{
if (handle->loads == 0)
return EIO;
handle->loads--;
3d15c: e5810024 str r0, [r1, #36] ; 0x24 <== NOT EXECUTED
if (handle->loads == 0)
3d160: 1a00000a bne 3d190 <rtems_rfs_inode_unload+0x68> <== NOT EXECUTED
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
3d164: e5d13010 ldrb r3, [r1, #16] <== NOT EXECUTED 3d168: e3530000 cmp r3, #0 <== NOT EXECUTED 3d16c: 0a000001 beq 3d178 <rtems_rfs_inode_unload+0x50> <== NOT EXECUTED 3d170: e3520000 cmp r2, #0 <== NOT EXECUTED 3d174: 1a000007 bne 3d198 <rtems_rfs_inode_unload+0x70> <== NOT EXECUTED
rtems_rfs_inode_set_ctime (handle, time (NULL));
rc = rtems_rfs_buffer_handle_release (fs, &handle->buffer);
3d178: e1a00005 mov r0, r5 <== NOT EXECUTED 3d17c: e2841010 add r1, r4, #16 <== NOT EXECUTED 3d180: ebfff1e9 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->node = NULL;
3d184: e3a03000 mov r3, #0 <== NOT EXECUTED
3d188: e584300c str r3, [r4, #12] <== NOT EXECUTED
3d18c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
3d190: e3a00000 mov r0, #0 <== NOT EXECUTED
}
}
return rc;
}
3d194: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
{
/*
* If the buffer is dirty it will be release. Also set the ctime.
*/
if (rtems_rfs_buffer_dirty (&handle->buffer) && update_ctime)
rtems_rfs_inode_set_ctime (handle, time (NULL));
3d198: eb004706 bl 4edb8 <time> <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_ctime (rtems_rfs_inode_handle* handle,
rtems_rfs_time ctime)
{
rtems_rfs_write_u32 (&handle->node->ctime, ctime);
3d19c: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3d1a0: e1a02c20 lsr r2, r0, #24 <== NOT EXECUTED 3d1a4: e5c32018 strb r2, [r3, #24] <== NOT EXECUTED 3d1a8: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3d1ac: e1a02820 lsr r2, r0, #16 <== NOT EXECUTED 3d1b0: e5c32019 strb r2, [r3, #25] <== NOT EXECUTED 3d1b4: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3d1b8: e1a02420 lsr r2, r0, #8 <== NOT EXECUTED 3d1bc: e5c3201a strb r2, [r3, #26] <== NOT EXECUTED 3d1c0: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3d1c4: e5c3001b strb r0, [r3, #27] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3d1c8: e3a03001 mov r3, #1 <== NOT EXECUTED 3d1cc: e5c43010 strb r3, [r4, #16] <== NOT EXECUTED 3d1d0: eaffffe8 b 3d178 <rtems_rfs_inode_unload+0x50> <== NOT EXECUTED
0003dc54 <rtems_rfs_link>:
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
3dc54: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3dc58: e24dd054 sub sp, sp, #84 ; 0x54 <== NOT EXECUTED
3dc5c: e59db078 ldr fp, [sp, #120] ; 0x78 <== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
3dc60: e28d5004 add r5, sp, #4 <== NOT EXECUTED
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
3dc64: e1a08001 mov r8, r1 <== NOT EXECUTED 3dc68: e1a0a002 mov sl, r2 <== NOT EXECUTED 3dc6c: e1a07003 mov r7, r3 <== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
3dc70: e1a0100b mov r1, fp <== NOT EXECUTED 3dc74: e1a02005 mov r2, r5 <== NOT EXECUTED 3dc78: e3a03001 mov r3, #1 <== NOT EXECUTED
const char* name,
int length,
rtems_rfs_ino parent,
rtems_rfs_ino target,
bool link_dir)
{
3dc7c: e1a04000 mov r4, r0 <== NOT EXECUTED 3dc80: e5dd607c ldrb r6, [sp, #124] ; 0x7c <== NOT EXECUTED
for (c = 0; c < length; c++)
printf ("%c", name[c]);
printf ("(%" PRIu32 ")\n", target);
}
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
3dc84: ebfffd76 bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
3dc88: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3dc8c: 1a000036 bne 3dd6c <rtems_rfs_link+0x118> <== NOT EXECUTED
/*
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
3dc90: e3560000 cmp r6, #0 <== NOT EXECUTED 3dc94: 1a000005 bne 3dcb0 <rtems_rfs_link+0x5c> <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
3dc98: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3dc9c: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 3dca0: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED 3dca4: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED 3dca8: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED 3dcac: 0a000038 beq 3dd94 <rtems_rfs_link+0x140> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return ENOTSUP;
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
3dcb0: e28d602c add r6, sp, #44 ; 0x2c <== NOT EXECUTED 3dcb4: e1a01007 mov r1, r7 <== NOT EXECUTED 3dcb8: e1a00004 mov r0, r4 <== NOT EXECUTED 3dcbc: e1a02006 mov r2, r6 <== NOT EXECUTED 3dcc0: e3a03001 mov r3, #1 <== NOT EXECUTED 3dcc4: ebfffd66 bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
3dcc8: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3dccc: 1a00002c bne 3dd84 <rtems_rfs_link+0x130> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
3dcd0: e1a02008 mov r2, r8 <== NOT EXECUTED 3dcd4: e1a0300a mov r3, sl <== NOT EXECUTED 3dcd8: e1a00004 mov r0, r4 <== NOT EXECUTED 3dcdc: e1a01006 mov r1, r6 <== NOT EXECUTED 3dce0: e58db000 str fp, [sp] <== NOT EXECUTED 3dce4: ebfff167 bl 3a288 <rtems_rfs_dir_add_entry> <== NOT EXECUTED
if (rc > 0)
3dce8: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3dcec: ca000021 bgt 3dd78 <rtems_rfs_link+0x124> <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
3dcf0: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 3dcf4: e5d30000 ldrb r0, [r3] <== NOT EXECUTED 3dcf8: e5d31001 ldrb r1, [r3, #1] <== NOT EXECUTED
if (links == 0xffff)
3dcfc: e3a02801 mov r2, #65536 ; 0x10000 <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
3dd00: e1811400 orr r1, r1, r0, lsl #8 <== NOT EXECUTED
if (links == 0xffff)
3dd04: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3dd08: e1510002 cmp r1, r2 <== NOT EXECUTED 3dd0c: 12811001 addne r1, r1, #1 <== NOT EXECUTED 3dd10: 11a01801 lslne r1, r1, #16 <== NOT EXECUTED 3dd14: 11a00821 lsrne r0, r1, #16 <== NOT EXECUTED 3dd18: 03a01000 moveq r1, #0 <== NOT EXECUTED 3dd1c: 11a01c21 lsrne r1, r1, #24 <== NOT EXECUTED
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
3dd20: e5c31000 strb r1, [r3] <== NOT EXECUTED 3dd24: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
if (links == 0xffff)
3dd28: 03a00001 moveq r0, #1 <== NOT EXECUTED 3dd2c: 120000ff andne r0, r0, #255 ; 0xff <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3dd30: e3a03001 mov r3, #1 <== NOT EXECUTED
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
3dd34: e5c20001 strb r0, [r2, #1] <== NOT EXECUTED
}
links = rtems_rfs_inode_get_links (&target_inode) + 1;
rtems_rfs_inode_set_links (&target_inode, links);
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
3dd38: e1a01003 mov r1, r3 <== NOT EXECUTED 3dd3c: e1a00006 mov r0, r6 <== NOT EXECUTED 3dd40: e1a02003 mov r2, r3 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3dd44: e5cd3014 strb r3, [sp, #20] <== NOT EXECUTED 3dd48: ebfffc70 bl 3cf10 <rtems_rfs_inode_time_stamp_now> <== NOT EXECUTED
if (rc > 0)
3dd4c: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3dd50: da000014 ble 3dda8 <rtems_rfs_link+0x154> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &parent_inode);
3dd54: e1a01006 mov r1, r6 <== NOT EXECUTED 3dd58: e1a00004 mov r0, r4 <== NOT EXECUTED 3dd5c: ebfffd1c bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
3dd60: e1a00004 mov r0, r4 <== NOT EXECUTED 3dd64: e1a01005 mov r1, r5 <== NOT EXECUTED 3dd68: ebfffd19 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
3dd6c: e1a00009 mov r0, r9 <== NOT EXECUTED
3dd70: e28dd054 add sp, sp, #84 ; 0x54 <== NOT EXECUTED
3dd74: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
}
rc = rtems_rfs_dir_add_entry (fs, &parent_inode, name, length, target);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &parent_inode);
3dd78: e1a01006 mov r1, r6 <== NOT EXECUTED 3dd7c: e1a00004 mov r0, r4 <== NOT EXECUTED 3dd80: ebfffd13 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
3dd84: e1a00004 mov r0, r4 <== NOT EXECUTED 3dd88: e1a01005 mov r1, r5 <== NOT EXECUTED 3dd8c: ebfffd10 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
3dd90: eafffff5 b 3dd6c <rtems_rfs_link+0x118> <== NOT EXECUTED
* If the target inode is a directory and we cannot link directories
* return a not supported error code.
*/
if (!link_dir && S_ISDIR (rtems_rfs_inode_get_mode (&target_inode)))
{
rtems_rfs_inode_close (fs, &target_inode);
3dd94: e1a00004 mov r0, r4 <== NOT EXECUTED 3dd98: e1a01005 mov r1, r5 <== NOT EXECUTED 3dd9c: ebfffd0c bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED 3dda0: e3a09086 mov r9, #134 ; 0x86 <== NOT EXECUTED
return ENOTSUP;
3dda4: eafffff0 b 3dd6c <rtems_rfs_link+0x118> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
3dda8: e1a01006 mov r1, r6 <== NOT EXECUTED 3ddac: e1a00004 mov r0, r4 <== NOT EXECUTED 3ddb0: ebfffd07 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
3ddb4: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3ddb8: cafffff1 bgt 3dd84 <rtems_rfs_link+0x130> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
3ddbc: e1a00004 mov r0, r4 <== NOT EXECUTED 3ddc0: e1a01005 mov r1, r5 <== NOT EXECUTED 3ddc4: ebfffd02 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED 3ddc8: e1a09000 mov r9, r0 <== NOT EXECUTED
return rc;
3ddcc: eaffffe6 b 3dd6c <rtems_rfs_link+0x118> <== NOT EXECUTED
0003ddec <rtems_rfs_mutex_create>:
RTEMS_NO_INHERIT_PRIORITY | RTEMS_NO_PRIORITY_CEILING | RTEMS_LOCAL)
#endif
int
rtems_rfs_mutex_create (rtems_rfs_mutex* mutex)
{
3ddec: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3ddf0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
#if __rtems__
rtems_status_code sc;
sc = rtems_semaphore_create (rtems_build_name ('R', 'F', 'S', 'm'),
3ddf4: e58d0000 str r0, [sp] <== NOT EXECUTED 3ddf8: e3a01001 mov r1, #1 <== NOT EXECUTED 3ddfc: e3a02024 mov r2, #36 ; 0x24 <== NOT EXECUTED 3de00: e3a03000 mov r3, #0 <== NOT EXECUTED 3de04: e59f0014 ldr r0, [pc, #20] ; 3de20 <rtems_rfs_mutex_create+0x34><== NOT EXECUTED 3de08: ebff38f8 bl c1f0 <rtems_semaphore_create> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
3de0c: e3500000 cmp r0, #0 <== NOT EXECUTED
3de10: 13a00005 movne r0, #5 <== NOT EXECUTED
3de14: 03a00000 moveq r0, #0 <== NOT EXECUTED
3de18: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3de1c: e8bd8000 pop {pc} <== NOT EXECUTED
0003ddd0 <rtems_rfs_mutex_destroy>:
return 0;
}
int
rtems_rfs_mutex_destroy (rtems_rfs_mutex* mutex)
{
3ddd0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
#if __rtems__ rtems_status_code sc; sc = rtems_semaphore_delete (*mutex);
3ddd4: e5900000 ldr r0, [r0] <== NOT EXECUTED 3ddd8: ebff3976 bl c3b8 <rtems_semaphore_delete> <== NOT EXECUTED
rtems_status_text (sc));
return EIO;
}
#endif
return 0;
}
3dddc: e3500000 cmp r0, #0 <== NOT EXECUTED
3dde0: 13a00005 movne r0, #5 <== NOT EXECUTED
3dde4: 03a00000 moveq r0, #0 <== NOT EXECUTED
3dde8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
00039764 <rtems_rfs_release_chain>:
static int
rtems_rfs_release_chain (rtems_chain_control* chain,
uint32_t* count,
bool modified)
{
39764: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
39768: e3a05000 mov r5, #0 <== NOT EXECUTED
3976c: e1a04000 mov r4, r0 <== NOT EXECUTED
39770: e1a06001 mov r6, r1 <== NOT EXECUTED
39774: e202a0ff and sl, r2, #255 ; 0xff <== NOT EXECUTED
39778: e2807004 add r7, r0, #4 <== NOT EXECUTED
while (!rtems_chain_is_empty (chain))
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
buffer->user = (void*) 0;
3977c: e1a08005 mov r8, r5 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
39780: ea00000d b 397bc <rtems_rfs_release_chain+0x58> <== NOT EXECUTED
*/
RTEMS_INLINE_ROUTINE rtems_chain_node *rtems_chain_get(
rtems_chain_control *the_chain
)
{
return _Chain_Get( the_chain );
39784: ebff4e52 bl d0d4 <_Chain_Get> <== NOT EXECUTED
{
buffer = (rtems_rfs_buffer*) rtems_chain_get (chain);
(*count)--;
39788: e5962000 ldr r2, [r6] <== NOT EXECUTED 3978c: e2422001 sub r2, r2, #1 <== NOT EXECUTED 39790: e5862000 str r2, [r6] <== NOT EXECUTED
buffer->user = (void*) 0;
39794: e5808038 str r8, [r0, #56] ; 0x38 <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (buffer, modified);
39798: e1a0100a mov r1, sl <== NOT EXECUTED 3979c: eb0024a2 bl 42a2c <rtems_rfs_buffer_bdbuf_release> <== NOT EXECUTED
if ((rc > 0) && (rrc == 0))
397a0: e3500000 cmp r0, #0 <== NOT EXECUTED 397a4: d3a03000 movle r3, #0 <== NOT EXECUTED 397a8: c3a03001 movgt r3, #1 <== NOT EXECUTED 397ac: e3550000 cmp r5, #0 <== NOT EXECUTED 397b0: 13a03000 movne r3, #0 <== NOT EXECUTED 397b4: e3530000 cmp r3, #0 <== NOT EXECUTED 397b8: 11a05000 movne r5, r0 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_BUFFER_CHAINS))
printf ("rtems-rfs: release-chain: count=%" PRIu32 "\n", *count);
while (!rtems_chain_is_empty (chain))
397bc: e5943000 ldr r3, [r4] <== NOT EXECUTED 397c0: e1530007 cmp r3, r7 <== NOT EXECUTED 397c4: e1a00004 mov r0, r4 <== NOT EXECUTED 397c8: 1affffed bne 39784 <rtems_rfs_release_chain+0x20> <== NOT EXECUTED
rc = rtems_rfs_buffer_io_release (buffer, modified);
if ((rc > 0) && (rrc == 0))
rrc = rc;
}
return rrc;
}
397cc: e1a00005 mov r0, r5 <== NOT EXECUTED
397d0: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
000226e0 <rtems_rfs_rtems_chown>:
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
226e0: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
226e4: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
226e8: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
226ec: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
226f0: e5908000 ldr r8, [r0] <== NOT EXECUTED
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
226f4: e1a06801 lsl r6, r1, #16 <== NOT EXECUTED 226f8: e3a01000 mov r1, #0 <== NOT EXECUTED 226fc: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 22700: e1a07802 lsl r7, r2, #16 <== NOT EXECUTED 22704: e5930000 ldr r0, [r3] <== NOT EXECUTED 22708: e1a02001 mov r2, r1 <== NOT EXECUTED 2270c: ebffa76c bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
printf ("rtems-rfs-rtems: chown: in: ino:%" PRId32 " uid:%d gid:%d\n",
ino, owner, group);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
22710: e1a01008 mov r1, r8 <== NOT EXECUTED 22714: e1a00004 mov r0, r4 <== NOT EXECUTED 22718: e1a0200d mov r2, sp <== NOT EXECUTED 2271c: e3a03001 mov r3, #1 <== NOT EXECUTED 22720: eb006acf bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
22724: e2508000 subs r8, r0, #0 <== NOT EXECUTED
static int
rtems_rfs_rtems_chown (rtems_filesystem_location_info_t *pathloc,
uid_t owner,
gid_t group)
{
22728: e1a06826 lsr r6, r6, #16 <== NOT EXECUTED 2272c: e1a07827 lsr r7, r7, #16 <== NOT EXECUTED
ino, owner, group);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc > 0)
22730: da000009 ble 2275c <rtems_rfs_rtems_chown+0x7c> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
22734: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
22738: e1a00004 mov r0, r4 <== NOT EXECUTED 2273c: eb005c24 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
22740: e5950000 ldr r0, [r5] <== NOT EXECUTED 22744: ebffa7a6 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("chown: opening inode", rc);
22748: eb008228 bl 42ff0 <__errno> <== NOT EXECUTED 2274c: e5808000 str r8, [r0] <== NOT EXECUTED 22750: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
22754: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
22758: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_uid_gid (rtems_rfs_inode_handle* handle,
uint16_t uid, uint16_t gid)
{
rtems_rfs_write_u32 (&handle->node->owner, (((uint32_t) gid) << 16) | uid);
2275c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 22760: e1867807 orr r7, r6, r7, lsl #16 <== NOT EXECUTED 22764: e1a02c27 lsr r2, r7, #24 <== NOT EXECUTED 22768: e5c32004 strb r2, [r3, #4] <== NOT EXECUTED 2276c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 22770: e1a02827 lsr r2, r7, #16 <== NOT EXECUTED 22774: e5c32005 strb r2, [r3, #5] <== NOT EXECUTED 22778: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 2277c: e1a07427 lsr r7, r7, #8 <== NOT EXECUTED 22780: e5c37006 strb r7, [r3, #6] <== NOT EXECUTED 22784: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
}
#endif
rtems_rfs_inode_set_uid_gid (&inode, owner, group);
rc = rtems_rfs_inode_close (fs, &inode);
22788: e1a0100d mov r1, sp <== NOT EXECUTED 2278c: e5c36007 strb r6, [r3, #7] <== NOT EXECUTED 22790: e1a00004 mov r0, r4 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
22794: e3a03001 mov r3, #1 <== NOT EXECUTED 22798: e5cd3010 strb r3, [sp, #16] <== NOT EXECUTED 2279c: eb006a8c bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc)
227a0: e2505000 subs r5, r0, #0 <== NOT EXECUTED 227a4: 0a000008 beq 227cc <rtems_rfs_rtems_chown+0xec> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
227a8: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
227ac: e1a00004 mov r0, r4 <== NOT EXECUTED 227b0: eb005c07 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 227b4: e5960000 ldr r0, [r6] <== NOT EXECUTED 227b8: ebffa789 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("chown: closing inode", rc);
227bc: eb00820b bl 42ff0 <__errno> <== NOT EXECUTED 227c0: e5805000 str r5, [r0] <== NOT EXECUTED 227c4: e3e00000 mvn r0, #0 <== NOT EXECUTED 227c8: eaffffe1 b 22754 <rtems_rfs_rtems_chown+0x74> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
227cc: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
227d0: e1a00004 mov r0, r4 <== NOT EXECUTED 227d4: eb005bfe bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 227d8: e5960000 ldr r0, [r6] <== NOT EXECUTED 227dc: ebffa780 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 227e0: e1a00005 mov r0, r5 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
227e4: eaffffda b 22754 <rtems_rfs_rtems_chown+0x74> <== NOT EXECUTED
0003df44 <rtems_rfs_rtems_device_close>:
* @return int
*/
static int
rtems_rfs_rtems_device_close (rtems_libio_t* iop)
{
3df44: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3df48: e1a03000 mov r3, r0 <== NOT EXECUTED
3df4c: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
rtems_libio_open_close_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
3df50: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.flags = 0;
3df54: e3a0c000 mov ip, #0 <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
3df58: e5931034 ldr r1, [r3, #52] ; 0x34 <== NOT EXECUTED
args.iop = iop;
args.flags = 0;
args.mode = 0;
status = rtems_io_close (major, minor, (void *) &args);
3df5c: e1a0200d mov r2, sp <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
3df60: e58d3000 str r3, [sp] <== NOT EXECUTED
args.flags = 0; args.mode = 0;
3df64: e58dc008 str ip, [sp, #8] <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.flags = 0;
3df68: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
args.mode = 0;
status = rtems_io_close (major, minor, (void *) &args);
3df6c: eb000897 bl 401d0 <rtems_io_close> <== NOT EXECUTED
if (status)
3df70: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3df74: 01a00003 moveq r0, r3 <== NOT EXECUTED
return rtems_deviceio_errno (status);
3df78: 1b00029c blne 3e9f0 <rtems_deviceio_errno> <== NOT EXECUTED
return 0;
}
3df7c: e28dd00c add sp, sp, #12 <== NOT EXECUTED
3df80: e8bd8000 pop {pc} <== NOT EXECUTED
0003de30 <rtems_rfs_rtems_device_ftruncate>:
static int
rtems_rfs_rtems_device_ftruncate (rtems_libio_t* iop, rtems_off64_t length)
{
return 0;
}
3de30: e3a00000 mov r0, #0 <== NOT EXECUTED 3de34: e12fff1e bx lr <== NOT EXECUTED
0003de38 <rtems_rfs_rtems_device_ioctl>:
static int
rtems_rfs_rtems_device_ioctl (rtems_libio_t* iop,
uint32_t command,
void* buffer)
{
3de38: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
3de3c: e1a03000 mov r3, r0 <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
3de40: e593c034 ldr ip, [r3, #52] ; 0x34 <== NOT EXECUTED
static int
rtems_rfs_rtems_device_ioctl (rtems_libio_t* iop,
uint32_t command,
void* buffer)
{
3de44: e24dd010 sub sp, sp, #16 <== NOT EXECUTED
rtems_libio_ioctl_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
3de48: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.command = command;
args.buffer = buffer;
3de4c: e98d0006 stmib sp, {r1, r2} <== NOT EXECUTED
status = rtems_io_control (major, minor, (void *) &args);
3de50: e1a0200d mov r2, sp <== NOT EXECUTED 3de54: e1a0100c mov r1, ip <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
3de58: e58d3000 str r3, [sp] <== NOT EXECUTED
args.command = command;
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
3de5c: eb0008ef bl 40220 <rtems_io_control> <== NOT EXECUTED
if (status)
3de60: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
return args.ioctl_return;
3de64: 059d000c ldreq r0, [sp, #12] <== NOT EXECUTED
args.iop = iop;
args.command = command;
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
if (status)
3de68: 1a000001 bne 3de74 <rtems_rfs_rtems_device_ioctl+0x3c> <== NOT EXECUTED
return rtems_deviceio_errno (status);
return args.ioctl_return;
}
3de6c: e28dd010 add sp, sp, #16 <== NOT EXECUTED
3de70: e8bd8000 pop {pc} <== NOT EXECUTED
args.command = command;
args.buffer = buffer;
status = rtems_io_control (major, minor, (void *) &args);
if (status)
return rtems_deviceio_errno (status);
3de74: eb0002dd bl 3e9f0 <rtems_deviceio_errno> <== NOT EXECUTED 3de78: eafffffb b 3de6c <rtems_rfs_rtems_device_ioctl+0x34> <== NOT EXECUTED
0003de24 <rtems_rfs_rtems_device_lseek>:
rtems_rfs_rtems_device_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
return offset;
}
3de24: e1a00001 mov r0, r1 <== NOT EXECUTED 3de28: e1a01002 mov r1, r2 <== NOT EXECUTED 3de2c: e12fff1e bx lr <== NOT EXECUTED
0003df84 <rtems_rfs_rtems_device_open>:
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode)
{
3df84: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_libio_open_close_args_t args; rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
3df88: e5902028 ldr r2, [r0, #40] ; 0x28 <== NOT EXECUTED 3df8c: e5924034 ldr r4, [r2, #52] ; 0x34 <== NOT EXECUTED 3df90: e594207c ldr r2, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
3df94: e5907038 ldr r7, [r0, #56] ; 0x38 <== NOT EXECUTED
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode)
{
3df98: e24dd044 sub sp, sp, #68 ; 0x44 <== NOT EXECUTED 3df9c: e3a01000 mov r1, #0 <== NOT EXECUTED 3dfa0: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_status_code status;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
3dfa4: e28d6010 add r6, sp, #16 <== NOT EXECUTED 3dfa8: e5920000 ldr r0, [r2] <== NOT EXECUTED 3dfac: e1a02001 mov r2, r1 <== NOT EXECUTED
static int
rtems_rfs_rtems_device_open ( rtems_libio_t *iop,
const char *pathname,
uint32_t flag,
uint32_t mode)
{
3dfb0: e1a08003 mov r8, r3 <== NOT EXECUTED 3dfb4: ebff3942 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_status_code status;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
3dfb8: e1a01007 mov r1, r7 <== NOT EXECUTED 3dfbc: e1a00004 mov r0, r4 <== NOT EXECUTED 3dfc0: e1a02006 mov r2, r6 <== NOT EXECUTED 3dfc4: e3a03001 mov r3, #1 <== NOT EXECUTED 3dfc8: ebfffca5 bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
3dfcc: e2507000 subs r7, r0, #0 <== NOT EXECUTED 3dfd0: da000009 ble 3dffc <rtems_rfs_rtems_device_open+0x78> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3dfd4: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3dfd8: e1a00004 mov r0, r4 <== NOT EXECUTED 3dfdc: ebffedfc bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
3dfe0: e5950000 ldr r0, [r5] <== NOT EXECUTED 3dfe4: ebff397e bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: opening inode", rc);
3dfe8: eb001400 bl 42ff0 <__errno> <== NOT EXECUTED 3dfec: e5807000 str r7, [r0] <== NOT EXECUTED 3dff0: e3e00000 mvn r0, #0 <== NOT EXECUTED
status = rtems_io_open (major, minor, (void *) &args);
if (status)
return rtems_deviceio_errno(status);
return 0;
}
3dff4: e28dd044 add sp, sp, #68 ; 0x44 <== NOT EXECUTED
3dff8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
3dffc: e59d201c ldr r2, [sp, #28] <== NOT EXECUTED 3e000: e282301c add r3, r2, #28 <== NOT EXECUTED 3e004: e5d2a01c ldrb sl, [r2, #28] <== NOT EXECUTED 3e008: e5d32007 ldrb r2, [r3, #7] <== NOT EXECUTED 3e00c: e58d2008 str r2, [sp, #8] <== NOT EXECUTED 3e010: e5d32002 ldrb r2, [r3, #2] <== NOT EXECUTED
}
major = rtems_rfs_inode_get_block (&inode, 0);
minor = rtems_rfs_inode_get_block (&inode, 1);
rc = rtems_rfs_inode_close (fs, &inode);
3e014: e1a01006 mov r1, r6 <== NOT EXECUTED 3e018: e5d36001 ldrb r6, [r3, #1] <== NOT EXECUTED 3e01c: e58d200c str r2, [sp, #12] <== NOT EXECUTED 3e020: e5d37003 ldrb r7, [r3, #3] <== NOT EXECUTED 3e024: e5d39004 ldrb r9, [r3, #4] <== NOT EXECUTED 3e028: e5d3b005 ldrb fp, [r3, #5] <== NOT EXECUTED 3e02c: e5d33006 ldrb r3, [r3, #6] <== NOT EXECUTED 3e030: e1a00004 mov r0, r4 <== NOT EXECUTED 3e034: e58d3004 str r3, [sp, #4] <== NOT EXECUTED 3e038: ebfffc65 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
3e03c: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3e040: da00000a ble 3e070 <rtems_rfs_rtems_device_open+0xec> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e044: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e048: e1a00004 mov r0, r4 <== NOT EXECUTED 3e04c: e58d3000 str r3, [sp] <== NOT EXECUTED 3e050: ebffeddf bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 3e054: e5950000 ldr r0, [r5] <== NOT EXECUTED 3e058: ebff3961 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
3e05c: eb0013e3 bl 42ff0 <__errno> <== NOT EXECUTED 3e060: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3e064: e5803000 str r3, [r0] <== NOT EXECUTED 3e068: e3e00000 mvn r0, #0 <== NOT EXECUTED 3e06c: eaffffe0 b 3dff4 <rtems_rfs_rtems_device_open+0x70> <== NOT EXECUTED 3e070: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3e074: e1a0b80b lsl fp, fp, #16 <== NOT EXECUTED 3e078: e18b9c09 orr r9, fp, r9, lsl #24 <== NOT EXECUTED 3e07c: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e080: e594b07c ldr fp, [r4, #124] ; 0x7c <== NOT EXECUTED 3e084: e1899003 orr r9, r9, r3 <== NOT EXECUTED 3e088: e1877c0a orr r7, r7, sl, lsl #24 <== NOT EXECUTED 3e08c: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED 3e090: e1876806 orr r6, r7, r6, lsl #16 <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e094: e1a00004 mov r0, r4 <== NOT EXECUTED 3e098: e1866402 orr r6, r6, r2, lsl #8 <== NOT EXECUTED 3e09c: e1899403 orr r9, r9, r3, lsl #8 <== NOT EXECUTED 3e0a0: ebffedcb bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 3e0a4: e59b0000 ldr r0, [fp] <== NOT EXECUTED 3e0a8: ebff394d bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
args.flags = iop->flags;
3e0ac: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
return rtems_rfs_rtems_error ("device_open: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
3e0b0: e5856030 str r6, [r5, #48] ; 0x30 <== NOT EXECUTED
iop->data1 = (void*)((intptr_t) minor);
3e0b4: e5859034 str r9, [r5, #52] ; 0x34 <== NOT EXECUTED
args.iop = iop;
args.flags = iop->flags;
args.mode = mode;
status = rtems_io_open (major, minor, (void *) &args);
3e0b8: e1a00006 mov r0, r6 <== NOT EXECUTED 3e0bc: e1a01009 mov r1, r9 <== NOT EXECUTED 3e0c0: e28d2038 add r2, sp, #56 ; 0x38 <== NOT EXECUTED
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
args.flags = iop->flags;
3e0c4: e58d303c str r3, [sp, #60] ; 0x3c <== NOT EXECUTED
args.mode = mode;
3e0c8: e58d8040 str r8, [sp, #64] ; 0x40 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
iop->data0 = major;
iop->data1 = (void*)((intptr_t) minor);
args.iop = iop;
3e0cc: e58d5038 str r5, [sp, #56] ; 0x38 <== NOT EXECUTED
args.flags = iop->flags;
args.mode = mode;
status = rtems_io_open (major, minor, (void *) &args);
3e0d0: eb000866 bl 40270 <rtems_io_open> <== NOT EXECUTED
if (status)
3e0d4: e2503000 subs r3, r0, #0 <== NOT EXECUTED 3e0d8: 01a00003 moveq r0, r3 <== NOT EXECUTED 3e0dc: 0affffc4 beq 3dff4 <rtems_rfs_rtems_device_open+0x70> <== NOT EXECUTED
return rtems_deviceio_errno(status);
3e0e0: eb000242 bl 3e9f0 <rtems_deviceio_errno> <== NOT EXECUTED 3e0e4: eaffffc2 b 3dff4 <rtems_rfs_rtems_device_open+0x70> <== NOT EXECUTED
0003dee0 <rtems_rfs_rtems_device_read>:
* @return ssize_t
*/
static ssize_t
rtems_rfs_rtems_device_read (rtems_libio_t* iop, void* buffer, size_t count)
{
3dee0: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3dee4: e1a03000 mov r3, r0 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
3dee8: e593c014 ldr ip, [r3, #20] <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
3deec: e593e034 ldr lr, [r3, #52] ; 0x34 <== NOT EXECUTED
* @return ssize_t
*/
static ssize_t
rtems_rfs_rtems_device_read (rtems_libio_t* iop, void* buffer, size_t count)
{
3def0: e24dd01c sub sp, sp, #28 <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
3def4: e283500c add r5, r3, #12 <== NOT EXECUTED
3def8: e8950030 ldm r5, {r4, r5} <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
3defc: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
args.buffer = buffer;
3df00: e58d100c str r1, [sp, #12] <== NOT EXECUTED
args.count = count;
3df04: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
args.flags = iop->flags;
3df08: e58dc014 str ip, [sp, #20] <== NOT EXECUTED
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
3df0c: e1a0100e mov r1, lr <== NOT EXECUTED
args.iop = iop; args.offset = iop->offset; args.buffer = buffer; args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
3df10: e3a0c000 mov ip, #0 <== NOT EXECUTED
status = rtems_io_read (major, minor, (void *) &args);
3df14: e1a0200d mov r2, sp <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
3df18: e98d0030 stmib sp, {r4, r5} <== NOT EXECUTED
args.buffer = buffer; args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
3df1c: e58dc018 str ip, [sp, #24] <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
3df20: e58d3000 str r3, [sp] <== NOT EXECUTED
args.buffer = buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
3df24: eb0008e5 bl 402c0 <rtems_io_read> <== NOT EXECUTED
if (status)
3df28: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
return (ssize_t) args.bytes_moved;
3df2c: 059d0018 ldreq r0, [sp, #24] <== NOT EXECUTED
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
if (status)
3df30: 1a000001 bne 3df3c <rtems_rfs_rtems_device_read+0x5c> <== NOT EXECUTED
return rtems_deviceio_errno (status);
return (ssize_t) args.bytes_moved;
}
3df34: e28dd01c add sp, sp, #28 <== NOT EXECUTED
3df38: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_read (major, minor, (void *) &args);
if (status)
return rtems_deviceio_errno (status);
3df3c: eb0002ab bl 3e9f0 <rtems_deviceio_errno> <== NOT EXECUTED 3df40: eafffffb b 3df34 <rtems_rfs_rtems_device_read+0x54> <== NOT EXECUTED
0003de7c <rtems_rfs_rtems_device_write>:
static ssize_t
rtems_rfs_rtems_device_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
3de7c: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3de80: e1a03000 mov r3, r0 <== NOT EXECUTED
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
3de84: e593c014 ldr ip, [r3, #20] <== NOT EXECUTED
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
3de88: e593e034 ldr lr, [r3, #52] ; 0x34 <== NOT EXECUTED
static ssize_t
rtems_rfs_rtems_device_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
3de8c: e24dd01c sub sp, sp, #28 <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
3de90: e283500c add r5, r3, #12 <== NOT EXECUTED
3de94: e8950030 ldm r5, {r4, r5} <== NOT EXECUTED
rtems_libio_rw_args_t args;
rtems_status_code status;
int major;
int minor;
major = (int) iop->data0;
3de98: e5900030 ldr r0, [r0, #48] ; 0x30 <== NOT EXECUTED
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
args.buffer = (void *) buffer;
3de9c: e58d100c str r1, [sp, #12] <== NOT EXECUTED
args.count = count;
3dea0: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
args.flags = iop->flags;
3dea4: e58dc014 str ip, [sp, #20] <== NOT EXECUTED
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
3dea8: e1a0100e mov r1, lr <== NOT EXECUTED
args.iop = iop; args.offset = iop->offset; args.buffer = (void *) buffer; args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
3deac: e3a0c000 mov ip, #0 <== NOT EXECUTED
status = rtems_io_write (major, minor, (void *) &args);
3deb0: e1a0200d mov r2, sp <== NOT EXECUTED
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
args.offset = iop->offset;
3deb4: e98d0030 stmib sp, {r4, r5} <== NOT EXECUTED
args.buffer = (void *) buffer; args.count = count; args.flags = iop->flags; args.bytes_moved = 0;
3deb8: e58dc018 str ip, [sp, #24] <== NOT EXECUTED
int minor;
major = (int) iop->data0;
minor = (intptr_t) iop->data1;
args.iop = iop;
3debc: e58d3000 str r3, [sp] <== NOT EXECUTED
args.buffer = (void *) buffer;
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
3dec0: eb000912 bl 40310 <rtems_io_write> <== NOT EXECUTED
if (status)
3dec4: e3500000 cmp r0, #0 <== NOT EXECUTED
return rtems_deviceio_errno (status);
return (ssize_t) args.bytes_moved;
3dec8: 059d0018 ldreq r0, [sp, #24] <== NOT EXECUTED
args.count = count;
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
if (status)
3decc: 1a000001 bne 3ded8 <rtems_rfs_rtems_device_write+0x5c> <== NOT EXECUTED
return rtems_deviceio_errno (status);
return (ssize_t) args.bytes_moved;
}
3ded0: e28dd01c add sp, sp, #28 <== NOT EXECUTED
3ded4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
args.flags = iop->flags;
args.bytes_moved = 0;
status = rtems_io_write (major, minor, (void *) &args);
if (status)
return rtems_deviceio_errno (status);
3ded8: eb0002c4 bl 3e9f0 <rtems_deviceio_errno> <== NOT EXECUTED 3dedc: eafffffb b 3ded0 <rtems_rfs_rtems_device_write+0x54> <== NOT EXECUTED
0003e0e8 <rtems_rfs_rtems_dir_close>:
{
/*
* The RFS does not hold any resources. Nothing to do.
*/
return 0;
}
3e0e8: e3a00000 mov r0, #0 <== NOT EXECUTED 3e0ec: e12fff1e bx lr <== NOT EXECUTED
0003e0f0 <rtems_rfs_rtems_dir_lseek>:
static rtems_off64_t
rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
switch (whence)
3e0f0: e3530001 cmp r3, #1 <== NOT EXECUTED
*/
static rtems_off64_t
rtems_rfs_rtems_dir_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
3e0f4: e92d4010 push {r4, lr} <== NOT EXECUTED
switch (whence)
3e0f8: 93a03000 movls r3, #0 <== NOT EXECUTED 3e0fc: 93a04000 movls r4, #0 <== NOT EXECUTED 3e100: 9a000004 bls 3e118 <rtems_rfs_rtems_dir_lseek+0x28> <== NOT EXECUTED
break;
case SEEK_END: /* Movement past the end of the directory via lseek */
/* is not a permitted operation */
default:
return rtems_rfs_rtems_error ("dir_lseek: bad whence", EINVAL);
3e104: eb0013b9 bl 42ff0 <__errno> <== NOT EXECUTED 3e108: e3a03016 mov r3, #22 <== NOT EXECUTED 3e10c: e5803000 str r3, [r0] <== NOT EXECUTED 3e110: e3e04000 mvn r4, #0 <== NOT EXECUTED 3e114: e3e03000 mvn r3, #0 <== NOT EXECUTED
break;
}
return 0;
}
3e118: e1a01004 mov r1, r4 <== NOT EXECUTED
3e11c: e1a00003 mov r0, r3 <== NOT EXECUTED
3e120: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0003e314 <rtems_rfs_rtems_dir_open>:
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
3e314: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
3e318: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
3e31c: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
3e320: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
3e324: e5907038 ldr r7, [r0, #56] ; 0x38 <== NOT EXECUTED 3e328: e3a01000 mov r1, #0 <== NOT EXECUTED
static int
rtems_rfs_rtems_dir_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
3e32c: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 3e330: e1a02001 mov r2, r1 <== NOT EXECUTED 3e334: e1a05000 mov r5, r0 <== NOT EXECUTED 3e338: e5930000 ldr r0, [r3] <== NOT EXECUTED 3e33c: ebff3860 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
3e340: e1a01007 mov r1, r7 <== NOT EXECUTED 3e344: e1a00004 mov r0, r4 <== NOT EXECUTED 3e348: e1a0200d mov r2, sp <== NOT EXECUTED 3e34c: e3a03001 mov r3, #1 <== NOT EXECUTED 3e350: ebfffbc3 bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
3e354: e2507000 subs r7, r0, #0 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
3e358: e1a0600d mov r6, sp <== NOT EXECUTED
if (rc)
3e35c: 1a000014 bne 3e3b4 <rtems_rfs_rtems_dir_open+0xa0> <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
3e360: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
3e364: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 3e368: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED 3e36c: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED 3e370: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED 3e374: 1a000017 bne 3e3d8 <rtems_rfs_rtems_dir_open+0xc4> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
}
iop->offset = 0;
3e378: e3a02000 mov r2, #0 <== NOT EXECUTED 3e37c: e3a03000 mov r3, #0 <== NOT EXECUTED 3e380: e585200c str r2, [r5, #12] <== NOT EXECUTED 3e384: e5853010 str r3, [r5, #16] <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
3e388: e1a0100d mov r1, sp <== NOT EXECUTED 3e38c: e1a00004 mov r0, r4 <== NOT EXECUTED 3e390: ebfffb8f bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e394: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e398: e1a00004 mov r0, r4 <== NOT EXECUTED 3e39c: ebffed0c bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
3e3a0: e5950000 ldr r0, [r5] <== NOT EXECUTED 3e3a4: ebff388e bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 3e3a8: e1a00007 mov r0, r7 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs); return 0; }
3e3ac: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
3e3b0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e3b4: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e3b8: e1a00004 mov r0, r4 <== NOT EXECUTED 3e3bc: ebffed04 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 3e3c0: e5950000 ldr r0, [r5] <== NOT EXECUTED 3e3c4: ebff3886 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: opening inode", rc);
3e3c8: eb001308 bl 42ff0 <__errno> <== NOT EXECUTED 3e3cc: e5807000 str r7, [r0] <== NOT EXECUTED 3e3d0: e3e00000 mvn r0, #0 <== NOT EXECUTED 3e3d4: eafffff4 b 3e3ac <rtems_rfs_rtems_dir_open+0x98> <== NOT EXECUTED
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
3e3d8: e1a0100d mov r1, sp <== NOT EXECUTED 3e3dc: e1a00004 mov r0, r4 <== NOT EXECUTED 3e3e0: ebfffb7b bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e3e4: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e3e8: e1a00004 mov r0, r4 <== NOT EXECUTED 3e3ec: ebffecf8 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 3e3f0: e5950000 ldr r0, [r5] <== NOT EXECUTED 3e3f4: ebff387a bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_open: not dir", ENOTDIR);
3e3f8: eb0012fc bl 42ff0 <__errno> <== NOT EXECUTED 3e3fc: e3a03014 mov r3, #20 <== NOT EXECUTED 3e400: e5803000 str r3, [r0] <== NOT EXECUTED 3e404: e3e00000 mvn r0, #0 <== NOT EXECUTED 3e408: eaffffe7 b 3e3ac <rtems_rfs_rtems_dir_open+0x98> <== NOT EXECUTED
0003e1d8 <rtems_rfs_rtems_dir_read>:
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
3e1d8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
3e1dc: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED 3e1e0: e5937034 ldr r7, [r3, #52] ; 0x34 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
3e1e4: e597307c ldr r3, [r7, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_iop_ino (iop);
3e1e8: e5904038 ldr r4, [r0, #56] ; 0x38 <== NOT EXECUTED
*/
static ssize_t
rtems_rfs_rtems_dir_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
3e1ec: e24dd038 sub sp, sp, #56 ; 0x38 <== NOT EXECUTED 3e1f0: e1a0a001 mov sl, r1 <== NOT EXECUTED 3e1f4: e3a01000 mov r1, #0 <== NOT EXECUTED 3e1f8: e1a06000 mov r6, r0 <== NOT EXECUTED 3e1fc: e1a05002 mov r5, r2 <== NOT EXECUTED 3e200: e5930000 ldr r0, [r3] <== NOT EXECUTED 3e204: e1a02001 mov r2, r1 <== NOT EXECUTED
count = count / sizeof (struct dirent);
dirent = buffer;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
3e208: e28d800c add r8, sp, #12 <== NOT EXECUTED 3e20c: ebff38ac bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED 3e210: e1a01004 mov r1, r4 <== NOT EXECUTED 3e214: e1a00007 mov r0, r7 <== NOT EXECUTED 3e218: e1a02008 mov r2, r8 <== NOT EXECUTED 3e21c: e3a03001 mov r3, #1 <== NOT EXECUTED 3e220: ebfffc0f bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
3e224: e2504000 subs r4, r0, #0 <== NOT EXECUTED 3e228: 1a000029 bne 3e2d4 <rtems_rfs_rtems_dir_read+0xfc> <== NOT EXECUTED
struct dirent* dirent;
ssize_t bytes_transferred;
int d;
int rc;
count = count / sizeof (struct dirent);
3e22c: e59f30dc ldr r3, [pc, #220] ; 3e310 <rtems_rfs_rtems_dir_read+0x138><== NOT EXECUTED 3e230: e08b2593 umull r2, fp, r3, r5 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
3e234: e1b0b42b lsrs fp, fp, #8 <== NOT EXECUTED 3e238: 01a0400b moveq r4, fp <== NOT EXECUTED 3e23c: 0a000019 beq 3e2a8 <rtems_rfs_rtems_dir_read+0xd0> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
3e240: e286300c add r3, r6, #12 <== NOT EXECUTED
3e244: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
3e248: e1a05004 mov r5, r4 <== NOT EXECUTED
3e24c: e28d9034 add r9, sp, #52 ; 0x34 <== NOT EXECUTED
3e250: ea00000b b 3e284 <rtems_rfs_rtems_dir_read+0xac> <== NOT EXECUTED
if (rc == ENOENT)
{
rc = 0;
break;
}
if (rc > 0)
3e254: e3500000 cmp r0, #0 <== NOT EXECUTED 3e258: ca000026 bgt 3e2f8 <rtems_rfs_rtems_dir_read+0x120> <== NOT EXECUTED
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
3e25c: e286100c add r1, r6, #12 <== NOT EXECUTED
3e260: e8910003 ldm r1, {r0, r1} <== NOT EXECUTED
3e264: e59dc034 ldr ip, [sp, #52] ; 0x34 <== NOT EXECUTED
3e268: e090200c adds r2, r0, ip <== NOT EXECUTED
3e26c: e2a13000 adc r3, r1, #0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
3e270: e15b0005 cmp fp, r5 <== NOT EXECUTED
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
break;
}
iop->offset += size;
3e274: e586200c str r2, [r6, #12] <== NOT EXECUTED 3e278: e5863010 str r3, [r6, #16] <== NOT EXECUTED 3e27c: e2844e11 add r4, r4, #272 ; 0x110 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
3e280: 9a000008 bls 3e2a8 <rtems_rfs_rtems_dir_read+0xd0> <== NOT EXECUTED
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
3e284: e08ac004 add ip, sl, r4 <== NOT EXECUTED 3e288: e1a00007 mov r0, r7 <== NOT EXECUTED 3e28c: e1a01008 mov r1, r8 <== NOT EXECUTED 3e290: e58dc000 str ip, [sp] <== NOT EXECUTED 3e294: e58d9004 str r9, [sp, #4] <== NOT EXECUTED 3e298: ebffee81 bl 39ca4 <rtems_rfs_dir_read> <== NOT EXECUTED
if (rc == ENOENT)
3e29c: e3500002 cmp r0, #2 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
}
bytes_transferred = 0;
for (d = 0; d < count; d++, dirent++)
3e2a0: e2855001 add r5, r5, #1 <== NOT EXECUTED
{
size_t size;
rc = rtems_rfs_dir_read (fs, &inode, iop->offset, dirent, &size);
if (rc == ENOENT)
3e2a4: 1affffea bne 3e254 <rtems_rfs_rtems_dir_read+0x7c> <== NOT EXECUTED
}
iop->offset += size;
bytes_transferred += sizeof (struct dirent);
}
rtems_rfs_inode_close (fs, &inode);
3e2a8: e1a01008 mov r1, r8 <== NOT EXECUTED 3e2ac: e1a00007 mov r0, r7 <== NOT EXECUTED 3e2b0: ebfffbc7 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e2b4: e597507c ldr r5, [r7, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e2b8: e1a00007 mov r0, r7 <== NOT EXECUTED 3e2bc: ebffed44 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
3e2c0: e5950000 ldr r0, [r5] <== NOT EXECUTED 3e2c4: ebff38c6 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return bytes_transferred;
}
3e2c8: e1a00004 mov r0, r4 <== NOT EXECUTED
3e2cc: e28dd038 add sp, sp, #56 ; 0x38 <== NOT EXECUTED
3e2d0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e2d4: e597507c ldr r5, [r7, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e2d8: e1a00007 mov r0, r7 <== NOT EXECUTED 3e2dc: ebffed3c bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 3e2e0: e5950000 ldr r0, [r5] <== NOT EXECUTED 3e2e4: ebff38be bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_read: read inode", rc);
3e2e8: eb001340 bl 42ff0 <__errno> <== NOT EXECUTED 3e2ec: e5804000 str r4, [r0] <== NOT EXECUTED 3e2f0: e3e04000 mvn r4, #0 <== NOT EXECUTED 3e2f4: eafffff3 b 3e2c8 <rtems_rfs_rtems_dir_read+0xf0> <== NOT EXECUTED
rc = 0;
break;
}
if (rc > 0)
{
bytes_transferred = rtems_rfs_rtems_error ("dir_read: dir read", rc);
3e2f8: e58d0008 str r0, [sp, #8] <== NOT EXECUTED 3e2fc: eb00133b bl 42ff0 <__errno> <== NOT EXECUTED 3e300: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 3e304: e3e04000 mvn r4, #0 <== NOT EXECUTED 3e308: e5803000 str r3, [r0] <== NOT EXECUTED 3e30c: eaffffe5 b 3e2a8 <rtems_rfs_rtems_dir_read+0xd0> <== NOT EXECUTED
0003e124 <rtems_rfs_rtems_dir_rmnod>:
static int
rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
3e124: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc); rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc); rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
3e128: e5915000 ldr r5, [r1] <== NOT EXECUTED
static int
rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
3e12c: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_DIR_RMNOD))
printf ("rtems-rfs: dir-rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
if (ino == RTEMS_RFS_ROOT_INO)
3e130: e3550001 cmp r5, #1 <== NOT EXECUTED
}
static int
rtems_rfs_rtems_dir_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
3e134: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
3e138: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
3e13c: e5907000 ldr r7, [r0] <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc); uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (pathloc);
3e140: e5916004 ldr r6, [r1, #4] <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_DIR_RMNOD))
printf ("rtems-rfs: dir-rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
if (ino == RTEMS_RFS_ROOT_INO)
3e144: 0a00001e beq 3e1c4 <rtems_rfs_rtems_dir_rmnod+0xa0> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
3e148: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED 3e14c: e3a01000 mov r1, #0 <== NOT EXECUTED 3e150: e1a02001 mov r2, r1 <== NOT EXECUTED 3e154: e5930000 ldr r0, [r3] <== NOT EXECUTED 3e158: ebff38d9 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_rmnod: root inode", EBUSY);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_if_empty);
3e15c: e1a02005 mov r2, r5 <== NOT EXECUTED 3e160: e3a0c001 mov ip, #1 <== NOT EXECUTED 3e164: e1a01007 mov r1, r7 <== NOT EXECUTED 3e168: e1a03006 mov r3, r6 <== NOT EXECUTED 3e16c: e1a00004 mov r0, r4 <== NOT EXECUTED 3e170: e58dc000 str ip, [sp] <== NOT EXECUTED 3e174: ebfffe32 bl 3da44 <rtems_rfs_unlink> <== NOT EXECUTED
if (rc)
3e178: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3e17c: 1a000007 bne 3e1a0 <rtems_rfs_rtems_dir_rmnod+0x7c> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e180: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e184: e1a00004 mov r0, r4 <== NOT EXECUTED 3e188: ebffed91 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
3e18c: e5960000 ldr r0, [r6] <== NOT EXECUTED 3e190: ebff3913 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 3e194: e1a00005 mov r0, r5 <== NOT EXECUTED
return rtems_rfs_rtems_error ("dir_rmnod: unlinking", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
3e198: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3e19c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e1a0: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e1a4: e1a00004 mov r0, r4 <== NOT EXECUTED 3e1a8: ebffed89 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 3e1ac: e5960000 ldr r0, [r6] <== NOT EXECUTED 3e1b0: ebff390b bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_if_empty);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("dir_rmnod: unlinking", rc);
3e1b4: eb00138d bl 42ff0 <__errno> <== NOT EXECUTED 3e1b8: e5805000 str r5, [r0] <== NOT EXECUTED 3e1bc: e3e00000 mvn r0, #0 <== NOT EXECUTED 3e1c0: eafffff4 b 3e198 <rtems_rfs_rtems_dir_rmnod+0x74> <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_DIR_RMNOD))
printf ("rtems-rfs: dir-rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
if (ino == RTEMS_RFS_ROOT_INO)
return rtems_rfs_rtems_error ("dir_rmnod: root inode", EBUSY);
3e1c4: eb001389 bl 42ff0 <__errno> <== NOT EXECUTED 3e1c8: e3a03010 mov r3, #16 <== NOT EXECUTED 3e1cc: e5803000 str r3, [r0] <== NOT EXECUTED 3e1d0: e3e00000 mvn r0, #0 <== NOT EXECUTED 3e1d4: eaffffef b 3e198 <rtems_rfs_rtems_dir_rmnod+0x74> <== NOT EXECUTED
00021fa0 <rtems_rfs_rtems_eval_for_make>:
*/
int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
21fa0: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
21fa4: e5913010 ldr r3, [r1, #16] <== NOT EXECUTED
*/
int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
21fa8: e1a09001 mov r9, r1 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc); rtems_rfs_inode_handle inode; rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
21fac: e5911000 ldr r1, [r1] <== NOT EXECUTED
*/
int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
21fb0: e24dd040 sub sp, sp, #64 ; 0x40 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc); rtems_rfs_inode_handle inode; rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
21fb4: e58d103c str r1, [sp, #60] ; 0x3c <== NOT EXECUTED
rtems_rfs_ino node_ino; uint32_t doff = 0;
21fb8: e3a01000 mov r1, #0 <== NOT EXECUTED
*/
int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
21fbc: e1a06002 mov r6, r2 <== NOT EXECUTED 21fc0: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc); rtems_rfs_inode_handle inode; rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc); rtems_rfs_ino node_ino; uint32_t doff = 0;
21fc4: e58d1034 str r1, [sp, #52] ; 0x34 <== NOT EXECUTED
int
rtems_rfs_rtems_eval_for_make (const char* path,
rtems_filesystem_location_info_t* pathloc,
const char** name)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
21fc8: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
int rc;
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
*name = path + strlen (path);
21fcc: eb009f04 bl 49be4 <strlen> <== NOT EXECUTED 21fd0: e0840000 add r0, r4, r0 <== NOT EXECUTED 21fd4: e5860000 str r0, [r6] <== NOT EXECUTED
while (*name != path)
21fd8: ea000000 b 21fe0 <rtems_rfs_rtems_eval_for_make+0x40> <== NOT EXECUTED
{
(*name)--;
if (rtems_filesystem_is_separator (**name))
{
(*name)++;
break;
21fdc: e5960000 ldr r0, [r6] <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
*name = path + strlen (path);
while (*name != path)
21fe0: e1540000 cmp r4, r0 <== NOT EXECUTED
{
(*name)--;
21fe4: e2403001 sub r3, r0, #1 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf ("rtems-rfs-rtems: eval-for-make: path:%s ino:%" PRId32 "\n", path, ino);
*name = path + strlen (path);
while (*name != path)
21fe8: 0a000007 beq 2200c <rtems_rfs_rtems_eval_for_make+0x6c> <== NOT EXECUTED
{
(*name)--;
21fec: e5863000 str r3, [r6] <== NOT EXECUTED
if (rtems_filesystem_is_separator (**name))
21ff0: e5500001 ldrb r0, [r0, #-1] <== NOT EXECUTED 21ff4: ebff9de7 bl 9798 <rtems_filesystem_is_separator> <== NOT EXECUTED 21ff8: e3500000 cmp r0, #0 <== NOT EXECUTED 21ffc: 0afffff6 beq 21fdc <rtems_rfs_rtems_eval_for_make+0x3c> <== NOT EXECUTED
{
(*name)++;
22000: e5963000 ldr r3, [r6] <== NOT EXECUTED 22004: e2833001 add r3, r3, #1 <== NOT EXECUTED 22008: e5863000 str r3, [r6] <== NOT EXECUTED
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen(path));
2200c: e1a00004 mov r0, r4 <== NOT EXECUTED 22010: eb009ef3 bl 49be4 <strlen> <== NOT EXECUTED 22014: e1a01000 mov r1, r0 <== NOT EXECUTED 22018: e1a00004 mov r0, r4 <== NOT EXECUTED 2201c: ebff96cf bl 7b60 <rtems_filesystem_prefix_separators> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
22020: e595307c ldr r3, [r5, #124] ; 0x7c <== NOT EXECUTED 22024: e3a01000 mov r1, #0 <== NOT EXECUTED
path += stripped;
22028: e0844000 add r4, r4, r0 <== NOT EXECUTED 2202c: e1a02001 mov r2, r1 <== NOT EXECUTED 22030: e5930000 ldr r0, [r3] <== NOT EXECUTED 22034: ebffa922 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED 22038: e28d700c add r7, sp, #12 <== NOT EXECUTED
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2203c: e1a00005 mov r0, r5 <== NOT EXECUTED 22040: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED 22044: e1a02007 mov r2, r7 <== NOT EXECUTED 22048: e3a03001 mov r3, #1 <== NOT EXECUTED 2204c: eb006c84 bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
22050: e2508000 subs r8, r0, #0 <== NOT EXECUTED 22054: ca0000b5 bgt 22330 <rtems_rfs_rtems_eval_for_make+0x390> <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
22058: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
}
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
2205c: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 22060: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED 22064: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED 22068: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED 2206c: 0a000061 beq 221f8 <rtems_rfs_rtems_eval_for_make+0x258> <== NOT EXECUTED
}
/*
* Is this the end of the pathname we where given ?
*/
if (path == *name)
22070: e5963000 ldr r3, [r6] <== NOT EXECUTED 22074: e1530004 cmp r3, r4 <== NOT EXECUTED 22078: 0a000035 beq 22154 <rtems_rfs_rtems_eval_for_make+0x1b4> <== NOT EXECUTED 2207c: e3a0a000 mov sl, #0 <== NOT EXECUTED 22080: ea000007 b 220a4 <rtems_rfs_rtems_eval_for_make+0x104> <== NOT EXECUTED
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
22084: e7d4300a ldrb r3, [r4, sl] <== NOT EXECUTED 22088: e3530000 cmp r3, #0 <== NOT EXECUTED 2208c: 0a000009 beq 220b8 <rtems_rfs_rtems_eval_for_make+0x118> <== NOT EXECUTED
(*path != '\0') &&
(node_len < (rtems_rfs_fs_max_name (fs) - 1)))
22090: e5953018 ldr r3, [r5, #24] <== NOT EXECUTED 22094: e2433001 sub r3, r3, #1 <== NOT EXECUTED 22098: e15a0003 cmp sl, r3 <== NOT EXECUTED 2209c: 2a000005 bcs 220b8 <rtems_rfs_rtems_eval_for_make+0x118> <== NOT EXECUTED
{
node_len++;
220a0: e28aa001 add sl, sl, #1 <== NOT EXECUTED
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
220a4: e7d4000a ldrb r0, [r4, sl] <== NOT EXECUTED 220a8: ebff9dba bl 9798 <rtems_filesystem_is_separator> <== NOT EXECUTED 220ac: e3500000 cmp r0, #0 <== NOT EXECUTED
* @param pathloc * @param name * @return int */ int rtems_rfs_rtems_eval_for_make (const char* path,
220b0: e084b00a add fp, r4, sl <== NOT EXECUTED
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator(*path) &&
220b4: 0afffff2 beq 22084 <rtems_rfs_rtems_eval_for_make+0xe4> <== NOT EXECUTED
}
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
220b8: e1a0000b mov r0, fp <== NOT EXECUTED 220bc: eb009ec8 bl 49be4 <strlen> <== NOT EXECUTED 220c0: e1a01000 mov r1, r0 <== NOT EXECUTED 220c4: e1a0000b mov r0, fp <== NOT EXECUTED 220c8: ebff96a4 bl 7b60 <rtems_filesystem_prefix_separators> <== NOT EXECUTED
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
220cc: e5d42000 ldrb r2, [r4] <== NOT EXECUTED 220d0: e352002e cmp r2, #46 ; 0x2e <== NOT EXECUTED
}
/*
* Eat any separators at start of the new path.
*/
stripped = rtems_filesystem_prefix_separators (path, strlen (path));
220d4: e1a03000 mov r3, r0 <== NOT EXECUTED
path += stripped;
220d8: e08b8000 add r8, fp, r0 <== NOT EXECUTED
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
220dc: 0a000016 beq 2213c <rtems_rfs_rtems_eval_for_make+0x19c> <== NOT EXECUTED
/*
* If the node is a parent we must move up one directory. If the location
* is on another file system we have a crossmount so we call that file
* system to handle the remainder of the path.
*/
if (rtems_rfs_parent_dir (path))
220e0: e7db3003 ldrb r3, [fp, r3] <== NOT EXECUTED 220e4: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED 220e8: 1a000002 bne 220f8 <rtems_rfs_rtems_eval_for_make+0x158> <== NOT EXECUTED 220ec: e5d83001 ldrb r3, [r8, #1] <== NOT EXECUTED 220f0: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED 220f4: 0a00004e beq 22234 <rtems_rfs_rtems_eval_for_make+0x294> <== NOT EXECUTED
else
{
/*
* Read the inode so we know it exists and what type it is.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
220f8: e1a02004 mov r2, r4 <== NOT EXECUTED
220fc: e1a0300a mov r3, sl <== NOT EXECUTED
22100: e1a00005 mov r0, r5 <== NOT EXECUTED
22104: e1a01007 mov r1, r7 <== NOT EXECUTED
22108: e28dc03c add ip, sp, #60 ; 0x3c <== NOT EXECUTED
2210c: e28de034 add lr, sp, #52 ; 0x34 <== NOT EXECUTED
22110: e88d5000 stm sp, {ip, lr} <== NOT EXECUTED
22114: eb00612e bl 3a5d4 <rtems_rfs_dir_lookup_ino> <== NOT EXECUTED
node, node_len - stripped, &ino, &doff);
if (rc > 0)
22118: e2504000 subs r4, r0, #0 <== NOT EXECUTED 2211c: ca000076 bgt 222fc <rtems_rfs_rtems_eval_for_make+0x35c> <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: down: path:%s ino:%" PRId32 "\n",
node, ino);
}
rc = rtems_rfs_inode_close (fs, &inode);
22120: e1a00005 mov r0, r5 <== NOT EXECUTED 22124: e1a01007 mov r1, r7 <== NOT EXECUTED 22128: eb006c29 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
2212c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 22130: ca000074 bgt 22308 <rtems_rfs_rtems_eval_for_make+0x368> <== NOT EXECUTED 22134: e1a04008 mov r4, r8 <== NOT EXECUTED 22138: eaffffbf b 2203c <rtems_rfs_rtems_eval_for_make+0x9c> <== NOT EXECUTED
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
2213c: e5d40001 ldrb r0, [r4, #1] <== NOT EXECUTED 22140: e3500000 cmp r0, #0 <== NOT EXECUTED 22144: 1a00004c bne 2227c <rtems_rfs_rtems_eval_for_make+0x2dc> <== NOT EXECUTED
{
if (*path)
22148: e7db3003 ldrb r3, [fp, r3] <== NOT EXECUTED 2214c: e3530000 cmp r3, #0 <== NOT EXECUTED 22150: 1a000051 bne 2229c <rtems_rfs_rtems_eval_for_make+0x2fc> <== NOT EXECUTED 22154: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: closing node", rc);
}
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
22158: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 2215c: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED 22160: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED 22164: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED 22168: 1a000076 bne 22348 <rtems_rfs_rtems_eval_for_make+0x3a8> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTDIR);
}
if (!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_WX))
2216c: e1a00007 mov r0, r7 <== NOT EXECUTED 22170: e3a01003 mov r1, #3 <== NOT EXECUTED 22174: eb0001d9 bl 228e0 <rtems_rfs_rtems_eval_perms> <== NOT EXECUTED 22178: e3500000 cmp r0, #0 <== NOT EXECUTED 2217c: 0a000022 beq 2220c <rtems_rfs_rtems_eval_for_make+0x26c> <== NOT EXECUTED
}
/*
* Make sure the name does not already exists in the directory.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, *name, strlen (*name),
22180: e5964000 ldr r4, [r6] <== NOT EXECUTED 22184: e1a00004 mov r0, r4 <== NOT EXECUTED 22188: eb009e95 bl 49be4 <strlen> <== NOT EXECUTED 2218c: e28dc038 add ip, sp, #56 ; 0x38 <== NOT EXECUTED 22190: e1a03000 mov r3, r0 <== NOT EXECUTED 22194: e1a02004 mov r2, r4 <== NOT EXECUTED 22198: e58dc000 str ip, [sp] <== NOT EXECUTED 2219c: e1a00005 mov r0, r5 <== NOT EXECUTED 221a0: e28dc034 add ip, sp, #52 ; 0x34 <== NOT EXECUTED 221a4: e1a01007 mov r1, r7 <== NOT EXECUTED 221a8: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 221ac: eb006108 bl 3a5d4 <rtems_rfs_dir_lookup_ino> <== NOT EXECUTED
&node_ino, &doff);
if (rc == 0)
221b0: e2504000 subs r4, r0, #0 <== NOT EXECUTED 221b4: 0a000081 beq 223c0 <rtems_rfs_rtems_eval_for_make+0x420> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: found name", EEXIST);
}
if (rc != ENOENT)
221b8: e3540002 cmp r4, #2 <== NOT EXECUTED 221bc: 0a00003b beq 222b0 <rtems_rfs_rtems_eval_for_make+0x310> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
221c0: e1a01007 mov r1, r7 <== NOT EXECUTED 221c4: e1a00005 mov r0, r5 <== NOT EXECUTED 221c8: eb006c01 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
221cc: e595607c ldr r6, [r5, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
221d0: e1a00005 mov r0, r5 <== NOT EXECUTED 221d4: eb005d7e bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
221d8: e5960000 ldr r0, [r6] <== NOT EXECUTED 221dc: ebffa900 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_for_make: look up", rc);
221e0: eb008382 bl 42ff0 <__errno> <== NOT EXECUTED 221e4: e5804000 str r4, [r0] <== NOT EXECUTED 221e8: e3e04000 mvn r4, #0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rc;
}
221ec: e1a00004 mov r0, r4 <== NOT EXECUTED
221f0: e28dd040 add sp, sp, #64 ; 0x40 <== NOT EXECUTED
221f4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
}
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
221f8: e1a00007 mov r0, r7 <== NOT EXECUTED 221fc: e3a01001 mov r1, #1 <== NOT EXECUTED 22200: eb0001b6 bl 228e0 <rtems_rfs_rtems_eval_perms> <== NOT EXECUTED 22204: e3500000 cmp r0, #0 <== NOT EXECUTED 22208: 1affff98 bne 22070 <rtems_rfs_rtems_eval_for_make+0xd0> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTDIR);
}
if (!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_WX))
{
rtems_rfs_inode_close (fs, &inode);
2220c: e1a01007 mov r1, r7 <== NOT EXECUTED 22210: e1a00005 mov r0, r5 <== NOT EXECUTED 22214: eb006bee bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
22218: e1a00005 mov r0, r5 <== NOT EXECUTED 2221c: ebfffbbd bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: cannot write", EACCES);
22220: eb008372 bl 42ff0 <__errno> <== NOT EXECUTED 22224: e3a0300d mov r3, #13 <== NOT EXECUTED 22228: e5803000 str r3, [r0] <== NOT EXECUTED 2222c: e3e04000 mvn r4, #0 <== NOT EXECUTED 22230: eaffffed b 221ec <rtems_rfs_rtems_eval_for_make+0x24c> <== NOT EXECUTED
/*
* If the node is a parent we must move up one directory. If the location
* is on another file system we have a crossmount so we call that file
* system to handle the remainder of the path.
*/
if (rtems_rfs_parent_dir (path))
22234: e5d80002 ldrb r0, [r8, #2] <== NOT EXECUTED 22238: e3500000 cmp r0, #0 <== NOT EXECUTED 2223c: e288b002 add fp, r8, #2 <== NOT EXECUTED 22240: 1a000036 bne 22320 <rtems_rfs_rtems_eval_for_make+0x380> <== NOT EXECUTED
{
/*
* If we are at the root inode of the file system we have a crossmount
* path.
*/
if (ino == RTEMS_RFS_ROOT_INO)
22244: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED 22248: e3530001 cmp r3, #1 <== NOT EXECUTED 2224c: 0a000047 beq 22370 <rtems_rfs_rtems_eval_for_make+0x3d0> <== NOT EXECUTED 22250: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED
/*
* If not a directory give and up return. We cannot change dir from a
* regular file or device node.
*/
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
22254: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 22258: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED 2225c: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED 22260: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED 22264: 1a00005f bne 223e8 <rtems_rfs_rtems_eval_for_make+0x448> <== NOT EXECUTED
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
22268: e1a00005 mov r0, r5 <== NOT EXECUTED 2226c: e1a01007 mov r1, r7 <== NOT EXECUTED 22270: e59f2198 ldr r2, [pc, #408] ; 22410 <rtems_rfs_rtems_eval_for_make+0x470><== NOT EXECUTED 22274: e3a03002 mov r3, #2 <== NOT EXECUTED 22278: eaffffa2 b 22108 <rtems_rfs_rtems_eval_for_make+0x168> <== NOT EXECUTED
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
2227c: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 22280: ebff9d44 bl 9798 <rtems_filesystem_is_separator> <== NOT EXECUTED 22284: e3500000 cmp r0, #0 <== NOT EXECUTED 22288: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 2228c: 0affff93 beq 220e0 <rtems_rfs_rtems_eval_for_make+0x140> <== NOT EXECUTED
{
if (*path)
22290: e7db3003 ldrb r3, [fp, r3] <== NOT EXECUTED 22294: e3530000 cmp r3, #0 <== NOT EXECUTED 22298: 0affffad beq 22154 <rtems_rfs_rtems_eval_for_make+0x1b4> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
2229c: e1a00005 mov r0, r5 <== NOT EXECUTED 222a0: e1a01007 mov r1, r7 <== NOT EXECUTED 222a4: eb006bca bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
222a8: e1a04008 mov r4, r8 <== NOT EXECUTED 222ac: eaffff62 b 2203c <rtems_rfs_rtems_eval_for_make+0x9c> <== NOT EXECUTED
/*
* Set the parent ino in the path location.
*/
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
222b0: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED 222b4: e5893000 str r3, [r9] <== NOT EXECUTED
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
222b8: e59d3034 ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
222bc: e1a01007 mov r1, r7 <== NOT EXECUTED
/*
* Set the parent ino in the path location.
*/
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
222c0: e5893004 str r3, [r9, #4] <== NOT EXECUTED
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
222c4: e1a00009 mov r0, r9 <== NOT EXECUTED 222c8: eb000195 bl 22924 <rtems_rfs_rtems_set_handlers> <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: parent ino:%" PRId32 " name:%s\n",
ino, *name);
rtems_rfs_inode_close (fs, &inode);
222cc: e1a01007 mov r1, r7 <== NOT EXECUTED
*/
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
222d0: e3500000 cmp r0, #0 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: parent ino:%" PRId32 " name:%s\n",
ino, *name);
rtems_rfs_inode_close (fs, &inode);
222d4: e1a00005 mov r0, r5 <== NOT EXECUTED
*/
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
222d8: 03a04005 moveq r4, #5 <== NOT EXECUTED 222dc: 13a04000 movne r4, #0 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: parent ino:%" PRId32 " name:%s\n",
ino, *name);
rtems_rfs_inode_close (fs, &inode);
222e0: eb006bbb bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
222e4: e595607c ldr r6, [r5, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
222e8: e1a00005 mov r0, r5 <== NOT EXECUTED 222ec: eb005d38 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
222f0: e5960000 ldr r0, [r6] <== NOT EXECUTED 222f4: ebffa8ba bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 222f8: eaffffbb b 221ec <rtems_rfs_rtems_eval_for_make+0x24c> <== NOT EXECUTED
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
node, node_len - stripped, &ino, &doff);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
222fc: e1a01007 mov r1, r7 <== NOT EXECUTED 22300: e1a00005 mov r0, r5 <== NOT EXECUTED 22304: eb006bb2 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &inode);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
22308: e1a00005 mov r0, r5 <== NOT EXECUTED 2230c: ebfffb81 bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: closing node", rc);
22310: eb008336 bl 42ff0 <__errno> <== NOT EXECUTED 22314: e5804000 str r4, [r0] <== NOT EXECUTED 22318: e3e04000 mvn r4, #0 <== NOT EXECUTED 2231c: eaffffb2 b 221ec <rtems_rfs_rtems_eval_for_make+0x24c> <== NOT EXECUTED
/*
* If the node is a parent we must move up one directory. If the location
* is on another file system we have a crossmount so we call that file
* system to handle the remainder of the path.
*/
if (rtems_rfs_parent_dir (path))
22320: ebff9d1c bl 9798 <rtems_filesystem_is_separator> <== NOT EXECUTED 22324: e3500000 cmp r0, #0 <== NOT EXECUTED 22328: 0affff72 beq 220f8 <rtems_rfs_rtems_eval_for_make+0x158> <== NOT EXECUTED 2232c: eaffffc4 b 22244 <rtems_rfs_rtems_eval_for_make+0x2a4> <== NOT EXECUTED
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
22330: e1a00005 mov r0, r5 <== NOT EXECUTED 22334: ebfffb77 bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: read ino", rc);
22338: eb00832c bl 42ff0 <__errno> <== NOT EXECUTED 2233c: e3e04000 mvn r4, #0 <== NOT EXECUTED 22340: e5808000 str r8, [r0] <== NOT EXECUTED 22344: eaffffa8 b 221ec <rtems_rfs_rtems_eval_for_make+0x24c> <== NOT EXECUTED
}
}
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
22348: e1a01007 mov r1, r7 <== NOT EXECUTED 2234c: e1a00005 mov r0, r5 <== NOT EXECUTED 22350: eb006b9f bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
22354: e1a00005 mov r0, r5 <== NOT EXECUTED 22358: ebfffb6e bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTDIR);
2235c: eb008323 bl 42ff0 <__errno> <== NOT EXECUTED 22360: e3a03014 mov r3, #20 <== NOT EXECUTED 22364: e5803000 str r3, [r0] <== NOT EXECUTED 22368: e3e04000 mvn r4, #0 <== NOT EXECUTED 2236c: eaffff9e b 221ec <rtems_rfs_rtems_eval_for_make+0x24c> <== NOT EXECUTED
{
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_FOR_MAKE))
printf("rtems-rfs-rtems: eval-for-make: crossmount: path:%s\n",
path - node_len);
rtems_rfs_inode_close (fs, &inode);
22370: e1a01007 mov r1, r7 <== NOT EXECUTED 22374: e1a00005 mov r0, r5 <== NOT EXECUTED 22378: eb006b95 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
2237c: e1a00005 mov r0, r5 <== NOT EXECUTED 22380: ebfffb64 bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
*pathloc = pathloc->mt_entry->mt_point_node;
22384: e599c010 ldr ip, [r9, #16] <== NOT EXECUTED
22388: e28cc008 add ip, ip, #8 <== NOT EXECUTED
2238c: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
22390: e1a0e009 mov lr, r9 <== NOT EXECUTED
22394: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
22398: e59c2000 ldr r2, [ip] <== NOT EXECUTED
2239c: e58e2000 str r2, [lr] <== NOT EXECUTED
return (*pathloc->ops->evalformake_h)(path + 2, pathloc, name);
223a0: e1a0000b mov r0, fp <== NOT EXECUTED 223a4: e1a01009 mov r1, r9 <== NOT EXECUTED 223a8: e1a02006 mov r2, r6 <== NOT EXECUTED 223ac: e599300c ldr r3, [r9, #12] <== NOT EXECUTED 223b0: e1a0e00f mov lr, pc <== NOT EXECUTED 223b4: e593f004 ldr pc, [r3, #4] <== NOT EXECUTED 223b8: e1a04000 mov r4, r0 <== NOT EXECUTED 223bc: eaffff8a b 221ec <rtems_rfs_rtems_eval_for_make+0x24c> <== NOT EXECUTED
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, *name, strlen (*name),
&node_ino, &doff);
if (rc == 0)
{
rtems_rfs_inode_close (fs, &inode);
223c0: e1a01007 mov r1, r7 <== NOT EXECUTED 223c4: e1a00005 mov r0, r5 <== NOT EXECUTED 223c8: eb006b81 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
223cc: e1a00005 mov r0, r5 <== NOT EXECUTED 223d0: ebfffb50 bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: found name", EEXIST);
223d4: eb008305 bl 42ff0 <__errno> <== NOT EXECUTED 223d8: e3a03011 mov r3, #17 <== NOT EXECUTED 223dc: e5803000 str r3, [r0] <== NOT EXECUTED 223e0: e3e04000 mvn r4, #0 <== NOT EXECUTED 223e4: eaffff80 b 221ec <rtems_rfs_rtems_eval_for_make+0x24c> <== NOT EXECUTED
* If not a directory give and up return. We cannot change dir from a
* regular file or device node.
*/
if (!RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)))
{
rtems_rfs_inode_close (fs, &inode);
223e8: e1a01007 mov r1, r7 <== NOT EXECUTED 223ec: e1a00005 mov r0, r5 <== NOT EXECUTED 223f0: eb006b77 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
223f4: e1a00005 mov r0, r5 <== NOT EXECUTED 223f8: ebfffb46 bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_for_make: not dir", ENOTSUP);
223fc: eb0082fb bl 42ff0 <__errno> <== NOT EXECUTED 22400: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 22404: e5803000 str r3, [r0] <== NOT EXECUTED 22408: e3e04000 mvn r4, #0 <== NOT EXECUTED 2240c: eaffff76 b 221ec <rtems_rfs_rtems_eval_for_make+0x24c> <== NOT EXECUTED
00021414 <rtems_rfs_rtems_eval_path>:
int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
21414: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
21418: e1a08003 mov r8, r3 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2141c: e5933010 ldr r3, [r3, #16] <== NOT EXECUTED 21420: e5936034 ldr r6, [r3, #52] ; 0x34 <== NOT EXECUTED
rtems_rfs_inode_handle inode; rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
21424: e5983000 ldr r3, [r8] <== NOT EXECUTED
int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
21428: e24dd044 sub sp, sp, #68 ; 0x44 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc); rtems_rfs_inode_handle inode; rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc); uint32_t doff = 0;
2142c: e3a07000 mov r7, #0 <== NOT EXECUTED
int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
21430: e1a05001 mov r5, r1 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc); rtems_rfs_inode_handle inode; rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
21434: e58d3040 str r3, [sp, #64] ; 0x40 <== NOT EXECUTED
int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
21438: e58d2010 str r2, [sp, #16] <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc); rtems_rfs_inode_handle inode; rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc); uint32_t doff = 0;
2143c: e58d703c str r7, [sp, #60] ; 0x3c <== NOT EXECUTED
int
rtems_rfs_rtems_eval_path (const char* path,
size_t pathlen,
int flags,
rtems_filesystem_location_info_t* pathloc)
{
21440: e1a04000 mov r4, r0 <== NOT EXECUTED
path, pathlen, ino);
/*
* Eat any separators at the start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
21444: ebff99c5 bl 7b60 <rtems_filesystem_prefix_separators> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
21448: e596207c ldr r2, [r6, #124] ; 0x7c <== NOT EXECUTED 2144c: e1a03000 mov r3, r0 <== NOT EXECUTED 21450: e1a01007 mov r1, r7 <== NOT EXECUTED 21454: e5920000 ldr r0, [r2] <== NOT EXECUTED 21458: e1a02007 mov r2, r7 <== NOT EXECUTED
path += stripped; pathlen -= stripped;
2145c: e0635005 rsb r5, r3, r5 <== NOT EXECUTED
/*
* Eat any separators at the start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
21460: e0844003 add r4, r4, r3 <== NOT EXECUTED 21464: ebffac16 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED 21468: e28d7014 add r7, sp, #20 <== NOT EXECUTED
while (true)
{
/*
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
2146c: e1a00006 mov r0, r6 <== NOT EXECUTED 21470: e59d1040 ldr r1, [sp, #64] ; 0x40 <== NOT EXECUTED 21474: e1a02007 mov r2, r7 <== NOT EXECUTED 21478: e3a03001 mov r3, #1 <== NOT EXECUTED 2147c: eb006f78 bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
21480: e3500000 cmp r0, #0 <== NOT EXECUTED 21484: ca00008b bgt 216b8 <rtems_rfs_rtems_eval_path+0x2a4> <== NOT EXECUTED
}
/*
* Is this the end of the pathname we where given ?
*/
if ((*path == '\0') || (pathlen == 0))
21488: e5d40000 ldrb r0, [r4] <== NOT EXECUTED 2148c: e3550000 cmp r5, #0 <== NOT EXECUTED 21490: 13500000 cmpne r0, #0 <== NOT EXECUTED 21494: 0a00003f beq 21598 <rtems_rfs_rtems_eval_path+0x184> <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
21498: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED
break;
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
2149c: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 214a0: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED 214a4: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED 214a8: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED 214ac: 0a00002b beq 21560 <rtems_rfs_rtems_eval_path+0x14c> <== NOT EXECUTED 214b0: e3a0a000 mov sl, #0 <== NOT EXECUTED 214b4: ea000009 b 214e0 <rtems_rfs_rtems_eval_path+0xcc> <== NOT EXECUTED
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
214b8: e7d4200a ldrb r2, [r4, sl] <== NOT EXECUTED 214bc: e3550000 cmp r5, #0 <== NOT EXECUTED 214c0: 13520000 cmpne r2, #0 <== NOT EXECUTED 214c4: 0a00000a beq 214f4 <rtems_rfs_rtems_eval_path+0xe0> <== NOT EXECUTED
(*path != '\0') && pathlen &&
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
214c8: e5962018 ldr r2, [r6, #24] <== NOT EXECUTED 214cc: e1530002 cmp r3, r2 <== NOT EXECUTED 214d0: 2a000007 bcs 214f4 <rtems_rfs_rtems_eval_path+0xe0> <== NOT EXECUTED
{
path++;
pathlen--;
214d4: e7d40003 ldrb r0, [r4, r3] <== NOT EXECUTED 214d8: e2455001 sub r5, r5, #1 <== NOT EXECUTED 214dc: e1a0a003 mov sl, r3 <== NOT EXECUTED
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
214e0: ebffa0ac bl 9798 <rtems_filesystem_is_separator> <== NOT EXECUTED 214e4: e3500000 cmp r0, #0 <== NOT EXECUTED
(*path != '\0') && pathlen &&
((node_len + 1) < rtems_rfs_fs_max_name (fs)))
214e8: e28a3001 add r3, sl, #1 <== NOT EXECUTED
* @param pathlen * @param flags * @param pathloc */ int rtems_rfs_rtems_eval_path (const char* path,
214ec: e084b00a add fp, r4, sl <== NOT EXECUTED
/*
* Extract the node name we will look for this time around.
*/
node = path;
node_len = 0;
while (!rtems_filesystem_is_separator (*path) &&
214f0: 0afffff0 beq 214b8 <rtems_rfs_rtems_eval_path+0xa4> <== NOT EXECUTED
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
214f4: e1a01005 mov r1, r5 <== NOT EXECUTED 214f8: e1a0000b mov r0, fp <== NOT EXECUTED 214fc: ebff9997 bl 7b60 <rtems_filesystem_prefix_separators> <== NOT EXECUTED
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
21500: e5d43000 ldrb r3, [r4] <== NOT EXECUTED 21504: e353002e cmp r3, #46 ; 0x2e <== NOT EXECUTED
}
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
21508: e1a09000 mov r9, r0 <== NOT EXECUTED
path += stripped;
pathlen -= stripped;
node_len += stripped;
2150c: e080300a add r3, r0, sl <== NOT EXECUTED
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
pathlen -= stripped;
21510: e0605005 rsb r5, r0, r5 <== NOT EXECUTED
/*
* Eat any separators at start of the path.
*/
stripped = rtems_filesystem_prefix_separators (path, pathlen);
path += stripped;
21514: e08ba000 add sl, fp, r0 <== NOT EXECUTED
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
21518: 0a000017 beq 2157c <rtems_rfs_rtems_eval_path+0x168> <== NOT EXECUTED
/*
* Look up the node name in this directory. If found drop through, close
* the current inode and let the loop open the inode so the mode can be
* read and handlers set.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
2151c: e28dc040 add ip, sp, #64 ; 0x40 <== NOT EXECUTED
21520: e28de03c add lr, sp, #60 ; 0x3c <== NOT EXECUTED
21524: e0693003 rsb r3, r9, r3 <== NOT EXECUTED
21528: e1a02004 mov r2, r4 <== NOT EXECUTED
2152c: e1a00006 mov r0, r6 <== NOT EXECUTED
21530: e1a01007 mov r1, r7 <== NOT EXECUTED
21534: e88d5000 stm sp, {ip, lr} <== NOT EXECUTED
21538: eb006425 bl 3a5d4 <rtems_rfs_dir_lookup_ino> <== NOT EXECUTED
node, node_len - stripped, &ino, &doff);
if (rc > 0)
2153c: e3500000 cmp r0, #0 <== NOT EXECUTED 21540: ca00004c bgt 21678 <rtems_rfs_rtems_eval_path+0x264> <== NOT EXECUTED
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: down: path:%s ino:%" PRId32 "\n", node, ino);
}
rc = rtems_rfs_inode_close (fs, &inode);
21544: e1a00006 mov r0, r6 <== NOT EXECUTED 21548: e1a01007 mov r1, r7 <== NOT EXECUTED 2154c: eb006f20 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
21550: e3500000 cmp r0, #0 <== NOT EXECUTED 21554: ca000047 bgt 21678 <rtems_rfs_rtems_eval_path+0x264> <== NOT EXECUTED 21558: e1a0400a mov r4, sl <== NOT EXECUTED 2155c: eaffffc2 b 2146c <rtems_rfs_rtems_eval_path+0x58> <== NOT EXECUTED
break;
/*
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
21560: e1a00007 mov r0, r7 <== NOT EXECUTED 21564: e3a01001 mov r1, #1 <== NOT EXECUTED 21568: eb0004dc bl 228e0 <rtems_rfs_rtems_eval_perms> <== NOT EXECUTED 2156c: e3500000 cmp r0, #0 <== NOT EXECUTED 21570: 0a00006d beq 2172c <rtems_rfs_rtems_eval_path+0x318> <== NOT EXECUTED 21574: e5d40000 ldrb r0, [r4] <== NOT EXECUTED 21578: eaffffcc b 214b0 <rtems_rfs_rtems_eval_path+0x9c> <== NOT EXECUTED
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
2157c: e5d40001 ldrb r0, [r4, #1] <== NOT EXECUTED 21580: e3500000 cmp r0, #0 <== NOT EXECUTED 21584: e2842001 add r2, r4, #1 <== NOT EXECUTED 21588: 1a000017 bne 215ec <rtems_rfs_rtems_eval_path+0x1d8> <== NOT EXECUTED
{
if (*path)
2158c: e7db3009 ldrb r3, [fp, r9] <== NOT EXECUTED 21590: e3530000 cmp r3, #0 <== NOT EXECUTED 21594: 1a000032 bne 21664 <rtems_rfs_rtems_eval_path+0x250> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("eval_path: closing node", rc);
}
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
21598: e59d3040 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED 2159c: e5883000 str r3, [r8] <== NOT EXECUTED
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
215a0: e59d303c ldr r3, [sp, #60] ; 0x3c <== NOT EXECUTED
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
215a4: e1a01007 mov r1, r7 <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_path: closing node", rc);
}
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
215a8: e5883004 str r3, [r8, #4] <== NOT EXECUTED
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
215ac: e1a00008 mov r0, r8 <== NOT EXECUTED 215b0: eb0004db bl 22924 <rtems_rfs_rtems_set_handlers> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
215b4: e1a01007 mov r1, r7 <== NOT EXECUTED
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
215b8: e3500000 cmp r0, #0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
215bc: e1a00006 mov r0, r6 <== NOT EXECUTED
}
rtems_rfs_rtems_set_pathloc_ino (pathloc, ino);
rtems_rfs_rtems_set_pathloc_doff (pathloc, doff);
rc = rtems_rfs_rtems_set_handlers (pathloc, &inode) ? 0 : EIO;
215c0: 03a04005 moveq r4, #5 <== NOT EXECUTED 215c4: 13a04000 movne r4, #0 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
215c8: eb006f01 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
215cc: e596507c ldr r5, [r6, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
215d0: e1a00006 mov r0, r6 <== NOT EXECUTED 215d4: eb00607e bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
215d8: e5950000 ldr r0, [r5] <== NOT EXECUTED 215dc: ebffac00 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: ino:%" PRId32 "\n", ino);
return rc;
}
215e0: e1a00004 mov r0, r4 <== NOT EXECUTED
215e4: e28dd044 add sp, sp, #68 ; 0x44 <== NOT EXECUTED
215e8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
/*
* If the node is the current directory and there is more path to come move
* on it else we are at the inode we want.
*/
if (rtems_rfs_current_dir (node))
215ec: e58d200c str r2, [sp, #12] <== NOT EXECUTED 215f0: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 215f4: ebffa067 bl 9798 <rtems_filesystem_is_separator> <== NOT EXECUTED 215f8: e3500000 cmp r0, #0 <== NOT EXECUTED 215fc: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 21600: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 21604: 1affffe0 bne 2158c <rtems_rfs_rtems_eval_path+0x178> <== NOT EXECUTED
/*
* If the node is a parent we must move up one directory. If the location
* is on another file system we have a crossmount so we call that file
* system to handle the remainder of the path.
*/
if (rtems_rfs_parent_dir (node))
21608: e5d41000 ldrb r1, [r4] <== NOT EXECUTED 2160c: e351002e cmp r1, #46 ; 0x2e <== NOT EXECUTED 21610: 1affffc1 bne 2151c <rtems_rfs_rtems_eval_path+0x108> <== NOT EXECUTED 21614: e5d22000 ldrb r2, [r2] <== NOT EXECUTED 21618: e352002e cmp r2, #46 ; 0x2e <== NOT EXECUTED 2161c: 1affffbe bne 2151c <rtems_rfs_rtems_eval_path+0x108> <== NOT EXECUTED 21620: e5d40002 ldrb r0, [r4, #2] <== NOT EXECUTED 21624: e3500000 cmp r0, #0 <== NOT EXECUTED 21628: 1a00001c bne 216a0 <rtems_rfs_rtems_eval_path+0x28c> <== NOT EXECUTED
{
/*
* If we are at root inode of the file system we have a crossmount path.
*/
if (ino == RTEMS_RFS_ROOT_INO)
2162c: e59d2040 ldr r2, [sp, #64] ; 0x40 <== NOT EXECUTED 21630: e3520001 cmp r2, #1 <== NOT EXECUTED 21634: 0a000026 beq 216d4 <rtems_rfs_rtems_eval_path+0x2c0> <== NOT EXECUTED
}
/*
* We need to find the parent of this node.
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode, "..", 2, &ino, &doff);
21638: e28dc040 add ip, sp, #64 ; 0x40 <== NOT EXECUTED
2163c: e28de03c add lr, sp, #60 ; 0x3c <== NOT EXECUTED
21640: e1a00006 mov r0, r6 <== NOT EXECUTED
21644: e1a01007 mov r1, r7 <== NOT EXECUTED
21648: e59f2104 ldr r2, [pc, #260] ; 21754 <rtems_rfs_rtems_eval_path+0x340><== NOT EXECUTED
2164c: e3a03002 mov r3, #2 <== NOT EXECUTED
21650: e88d5000 stm sp, {ip, lr} <== NOT EXECUTED
21654: eb0063de bl 3a5d4 <rtems_rfs_dir_lookup_ino> <== NOT EXECUTED
if (rc > 0)
21658: e2504000 subs r4, r0, #0 <== NOT EXECUTED 2165c: daffffb8 ble 21544 <rtems_rfs_rtems_eval_path+0x130> <== NOT EXECUTED 21660: ea000005 b 2167c <rtems_rfs_rtems_eval_path+0x268> <== NOT EXECUTED
*/
if (rtems_rfs_current_dir (node))
{
if (*path)
{
rtems_rfs_inode_close (fs, &inode);
21664: e1a00006 mov r0, r6 <== NOT EXECUTED 21668: e1a01007 mov r1, r7 <== NOT EXECUTED 2166c: eb006ed8 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
21670: e1a0400a mov r4, sl <== NOT EXECUTED 21674: eaffff7c b 2146c <rtems_rfs_rtems_eval_path+0x58> <== NOT EXECUTED 21678: e1a04000 mov r4, r0 <== NOT EXECUTED
*/
rc = rtems_rfs_dir_lookup_ino (fs, &inode,
node, node_len - stripped, &ino, &doff);
if (rc > 0)
{
rtems_rfs_inode_close (fs, &inode);
2167c: e1a01007 mov r1, r7 <== NOT EXECUTED 21680: e1a00006 mov r0, r6 <== NOT EXECUTED 21684: eb006ed2 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
21688: e1a00006 mov r0, r6 <== NOT EXECUTED 2168c: ebfffea1 bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return ((errno = rc) == 0) ? 0 : -1;
21690: eb008656 bl 42ff0 <__errno> <== NOT EXECUTED 21694: e5804000 str r4, [r0] <== NOT EXECUTED 21698: e3e04000 mvn r4, #0 <== NOT EXECUTED 2169c: eaffffcf b 215e0 <rtems_rfs_rtems_eval_path+0x1cc> <== NOT EXECUTED
/*
* If the node is a parent we must move up one directory. If the location
* is on another file system we have a crossmount so we call that file
* system to handle the remainder of the path.
*/
if (rtems_rfs_parent_dir (node))
216a0: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 216a4: ebffa03b bl 9798 <rtems_filesystem_is_separator> <== NOT EXECUTED 216a8: e3500000 cmp r0, #0 <== NOT EXECUTED 216ac: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 216b0: 0affff99 beq 2151c <rtems_rfs_rtems_eval_path+0x108> <== NOT EXECUTED 216b4: eaffffdc b 2162c <rtems_rfs_rtems_eval_path+0x218> <== NOT EXECUTED 216b8: e1a0a000 mov sl, r0 <== NOT EXECUTED
* Open and load the inode.
*/
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc > 0)
{
rtems_rfs_rtems_unlock (fs);
216bc: e1a00006 mov r0, r6 <== NOT EXECUTED 216c0: ebfffe94 bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_path: opening inode", rc);
216c4: eb008649 bl 42ff0 <__errno> <== NOT EXECUTED 216c8: e3e04000 mvn r4, #0 <== NOT EXECUTED 216cc: e580a000 str sl, [r0] <== NOT EXECUTED 216d0: eaffffc2 b 215e0 <rtems_rfs_rtems_eval_path+0x1cc> <== NOT EXECUTED
if (ino == RTEMS_RFS_ROOT_INO)
{
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PATH))
printf("rtems-rfs-rtems: eval-path: crossmount: path:%s (%zd)\n",
path - node_len, pathlen + node_len);
rtems_rfs_inode_close (fs, &inode);
216d4: e1a01007 mov r1, r7 <== NOT EXECUTED 216d8: e1a00006 mov r0, r6 <== NOT EXECUTED 216dc: e1a09003 mov r9, r3 <== NOT EXECUTED 216e0: eb006ebb bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
216e4: e1a00006 mov r0, r6 <== NOT EXECUTED 216e8: ebfffe8a bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
*pathloc = pathloc->mt_entry->mt_point_node;
216ec: e598c010 ldr ip, [r8, #16] <== NOT EXECUTED
216f0: e28cc008 add ip, ip, #8 <== NOT EXECUTED
216f4: e8bc000f ldm ip!, {r0, r1, r2, r3} <== NOT EXECUTED
216f8: e1a0e008 mov lr, r8 <== NOT EXECUTED
216fc: e8ae000f stmia lr!, {r0, r1, r2, r3} <== NOT EXECUTED
21700: e59c2000 ldr r2, [ip] <== NOT EXECUTED
21704: e58e2000 str r2, [lr] <== NOT EXECUTED
return (*pathloc->ops->evalpath_h)(path - node_len, pathlen + node_len,
21708: e0891005 add r1, r9, r5 <== NOT EXECUTED 2170c: e069000a rsb r0, r9, sl <== NOT EXECUTED 21710: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED 21714: e1a03008 mov r3, r8 <== NOT EXECUTED 21718: e598c00c ldr ip, [r8, #12] <== NOT EXECUTED 2171c: e1a0e00f mov lr, pc <== NOT EXECUTED 21720: e59cf000 ldr pc, [ip] <== NOT EXECUTED 21724: e1a04000 mov r4, r0 <== NOT EXECUTED 21728: eaffffac b 215e0 <rtems_rfs_rtems_eval_path+0x1cc> <== NOT EXECUTED
* If a directory the execute bit must be set for us to enter.
*/
if (RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&inode)) &&
!rtems_rfs_rtems_eval_perms (&inode, RTEMS_LIBIO_PERMS_SEARCH))
{
rtems_rfs_inode_close (fs, &inode);
2172c: e1a01007 mov r1, r7 <== NOT EXECUTED 21730: e1a00006 mov r0, r6 <== NOT EXECUTED 21734: eb006ea6 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
21738: e1a00006 mov r0, r6 <== NOT EXECUTED 2173c: ebfffe75 bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("eval_path: eval perms", EACCES);
21740: eb00862a bl 42ff0 <__errno> <== NOT EXECUTED 21744: e3a0300d mov r3, #13 <== NOT EXECUTED 21748: e5803000 str r3, [r0] <== NOT EXECUTED 2174c: e3e04000 mvn r4, #0 <== NOT EXECUTED 21750: eaffffa2 b 215e0 <rtems_rfs_rtems_eval_path+0x1cc> <== NOT EXECUTED
000228e0 <rtems_rfs_rtems_eval_perms>:
228e0: e590300c ldr r3, [r0, #12] <== NOT EXECUTED
* Check if I am owner or a group member or someone else.
*/
flags_to_test = flags;
if ((st_uid == 0) || (st_uid == uid))
flags_to_test |= flags << 6;
228e4: e1a02181 lsl r2, r1, #3 <== NOT EXECUTED 228e8: e1822301 orr r2, r2, r1, lsl #6 <== NOT EXECUTED 228ec: e1821001 orr r1, r2, r1 <== NOT EXECUTED 228f0: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED 228f4: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 228f8: e1a01b81 lsl r1, r1, #23 <== NOT EXECUTED 228fc: e1823403 orr r3, r2, r3, lsl #8 <== NOT EXECUTED 22900: e1a01ba1 lsr r1, r1, #23 <== NOT EXECUTED 22904: e1110003 tst r1, r3 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_EVAL_PERMS))
printf("rtems-rfs: eval-perms: perms failed\n");
return false;
}
22908: 03a00000 moveq r0, #0 <== NOT EXECUTED 2290c: 13a00001 movne r0, #1 <== NOT EXECUTED 22910: e12fff1e bx lr <== NOT EXECUTED
000225e4 <rtems_rfs_rtems_fchmod>:
*/
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
225e4: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
225e8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
225ec: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
225f0: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
225f4: e5907000 ldr r7, [r0] <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_fchmod (rtems_filesystem_location_info_t* pathloc,
mode_t mode)
{
225f8: e1a06001 mov r6, r1 <== NOT EXECUTED 225fc: e3a01000 mov r1, #0 <== NOT EXECUTED 22600: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 22604: e1a02001 mov r2, r1 <== NOT EXECUTED 22608: e5930000 ldr r0, [r3] <== NOT EXECUTED 2260c: ebffa7ac bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
printf ("rtems-rfs-rtems: fchmod: in: ino:%" PRId32 " mode:%06" PRIomode_t "\n",
ino, mode);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
22610: e1a01007 mov r1, r7 <== NOT EXECUTED 22614: e1a00004 mov r0, r4 <== NOT EXECUTED 22618: e1a0200d mov r2, sp <== NOT EXECUTED 2261c: e3a03001 mov r3, #1 <== NOT EXECUTED 22620: eb006b0f bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
22624: e2507000 subs r7, r0, #0 <== NOT EXECUTED 22628: 0a000009 beq 22654 <rtems_rfs_rtems_fchmod+0x70> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
2262c: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
22630: e1a00004 mov r0, r4 <== NOT EXECUTED 22634: eb005c66 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
22638: e5950000 ldr r0, [r5] <== NOT EXECUTED 2263c: ebffa7e8 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("fchmod: opening inode", rc);
22640: eb00826a bl 42ff0 <__errno> <== NOT EXECUTED 22644: e5807000 str r7, [r0] <== NOT EXECUTED 22648: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
2264c: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
22650: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
22654: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 22658: e5d32002 ldrb r2, [r3, #2] <== NOT EXECUTED 2265c: e1a02402 lsl r2, r2, #8 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("fchmod: not owner", EPERM);
}
#endif
imode &= ~(S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
22660: e2022a0f and r2, r2, #61440 ; 0xf000 <== NOT EXECUTED
imode |= mode & (S_IRWXU | S_IRWXG | S_IRWXO | S_ISUID | S_ISGID | S_ISVTX);
22664: e3c66a0f bic r6, r6, #61440 ; 0xf000 <== NOT EXECUTED 22668: e1826006 orr r6, r2, r6 <== NOT EXECUTED 2266c: e1a06806 lsl r6, r6, #16 <== NOT EXECUTED
* @prarm mode The mode.
*/
static inline void
rtems_rfs_inode_set_mode (rtems_rfs_inode_handle* handle, uint16_t mode)
{
rtems_rfs_write_u16 (&handle->node->mode, mode);
22670: e1a02c26 lsr r2, r6, #24 <== NOT EXECUTED 22674: e5c32002 strb r2, [r3, #2] <== NOT EXECUTED 22678: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 2267c: e1a06826 lsr r6, r6, #16 <== NOT EXECUTED 22680: e5c36003 strb r6, [r3, #3] <== NOT EXECUTED
rtems_rfs_inode_set_mode (&inode, imode);
rc = rtems_rfs_inode_close (fs, &inode);
22684: e1a0100d mov r1, sp <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
22688: e3a03001 mov r3, #1 <== NOT EXECUTED 2268c: e1a00004 mov r0, r4 <== NOT EXECUTED 22690: e5cd3010 strb r3, [sp, #16] <== NOT EXECUTED 22694: eb006ace bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
22698: e2505000 subs r5, r0, #0 <== NOT EXECUTED 2269c: da000008 ble 226c4 <rtems_rfs_rtems_fchmod+0xe0> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
226a0: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
226a4: e1a00004 mov r0, r4 <== NOT EXECUTED 226a8: eb005c49 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 226ac: e5960000 ldr r0, [r6] <== NOT EXECUTED 226b0: ebffa7cb bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("fchmod: closing inode", rc);
226b4: eb00824d bl 42ff0 <__errno> <== NOT EXECUTED 226b8: e5805000 str r5, [r0] <== NOT EXECUTED 226bc: e3e00000 mvn r0, #0 <== NOT EXECUTED 226c0: eaffffe1 b 2264c <rtems_rfs_rtems_fchmod+0x68> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
226c4: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
226c8: e1a00004 mov r0, r4 <== NOT EXECUTED 226cc: eb005c40 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 226d0: e5950000 ldr r0, [r5] <== NOT EXECUTED 226d4: ebffa7c2 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 226d8: e1a00007 mov r0, r7 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
226dc: eaffffda b 2264c <rtems_rfs_rtems_fchmod+0x68> <== NOT EXECUTED
00021110 <rtems_rfs_rtems_fcntl>:
int
rtems_rfs_rtems_fcntl (int cmd,
rtems_libio_t* iop)
{
return 0;
}
21110: e3a00000 mov r0, #0 <== NOT EXECUTED 21114: e12fff1e bx lr <== NOT EXECUTED
000213e8 <rtems_rfs_rtems_fdatasync>:
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
213e8: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
* @param iop
* @return int
*/
int
rtems_rfs_rtems_fdatasync (rtems_libio_t* iop)
{
213ec: e92d4010 push {r4, lr} <== NOT EXECUTED
int rc;
rc = rtems_rfs_buffer_sync (rtems_rfs_rtems_pathloc_dev (&iop->pathinfo));
213f0: e5930034 ldr r0, [r3, #52] ; 0x34 <== NOT EXECUTED 213f4: eb006108 bl 3981c <rtems_rfs_buffer_sync> <== NOT EXECUTED
if (rc)
213f8: e2504000 subs r4, r0, #0 <== NOT EXECUTED
213fc: 01a00004 moveq r0, r4 <== NOT EXECUTED
21400: 08bd8010 popeq {r4, pc} <== NOT EXECUTED
return rtems_rfs_rtems_error ("fdatasync: sync", rc);
21404: eb0086f9 bl 42ff0 <__errno> <== NOT EXECUTED 21408: e5804000 str r4, [r0] <== NOT EXECUTED 2140c: e3e00000 mvn r0, #0 <== NOT EXECUTED
return 0;
}
21410: e8bd8010 pop {r4, pc} <== NOT EXECUTED
0003e544 <rtems_rfs_rtems_file_close>:
* @param iop
* @return int
*/
static int
rtems_rfs_rtems_file_close (rtems_libio_t* iop)
{
3e544: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
rtems_rfs_file_handle* file = iop->file_info;
3e548: e5905038 ldr r5, [r0, #56] ; 0x38 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_file_fs (file);
3e54c: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3e550: e5934098 ldr r4, [r3, #152] ; 0x98 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
3e554: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED 3e558: e3a01000 mov r1, #0 <== NOT EXECUTED 3e55c: e1a02001 mov r2, r1 <== NOT EXECUTED 3e560: e5930000 ldr r0, [r3] <== NOT EXECUTED 3e564: ebff37d6 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_CLOSE))
printf("rtems-rfs: file-close: handle:%p\n", file);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_file_close (fs, file);
3e568: e1a01005 mov r1, r5 <== NOT EXECUTED 3e56c: e1a00004 mov r0, r4 <== NOT EXECUTED 3e570: ebfff306 bl 3b190 <rtems_rfs_file_close> <== NOT EXECUTED
if (rc > 0)
3e574: e2505000 subs r5, r0, #0 <== NOT EXECUTED 3e578: da000002 ble 3e588 <rtems_rfs_rtems_file_close+0x44> <== NOT EXECUTED
rc = rtems_rfs_rtems_error ("file-close: file close", rc);
3e57c: eb00129b bl 42ff0 <__errno> <== NOT EXECUTED 3e580: e5805000 str r5, [r0] <== NOT EXECUTED 3e584: e3e05000 mvn r5, #0 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e588: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e58c: e1a00004 mov r0, r4 <== NOT EXECUTED 3e590: ebffec8f bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
3e594: e5960000 ldr r0, [r6] <== NOT EXECUTED 3e598: ebff3811 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rc;
}
3e59c: e1a00005 mov r0, r5 <== NOT EXECUTED
3e5a0: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
0003e5a4 <rtems_rfs_rtems_file_ftruncate>:
* @return int
*/
int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
rtems_off64_t length)
{
3e5a4: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_rfs_file_handle* file = iop->file_info;
3e5a8: e5904038 ldr r4, [r0, #56] ; 0x38 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
3e5ac: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3e5b0: e5933098 ldr r3, [r3, #152] ; 0x98 <== NOT EXECUTED 3e5b4: e593307c ldr r3, [r3, #124] ; 0x7c <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_file_ftruncate (rtems_libio_t* iop,
rtems_off64_t length)
{
3e5b8: e1a06001 mov r6, r1 <== NOT EXECUTED 3e5bc: e3a01000 mov r1, #0 <== NOT EXECUTED 3e5c0: e1a07002 mov r7, r2 <== NOT EXECUTED 3e5c4: e1a05000 mov r5, r0 <== NOT EXECUTED 3e5c8: e1a02001 mov r2, r1 <== NOT EXECUTED 3e5cc: e5930000 ldr r0, [r3] <== NOT EXECUTED 3e5d0: ebff37bb bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_FTRUNC))
printf("rtems-rfs: file-ftrunc: handle:%p length:%Ld\n", file, length);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
rc = rtems_rfs_file_set_size (file, length);
3e5d4: e1a01006 mov r1, r6 <== NOT EXECUTED 3e5d8: e1a00004 mov r0, r4 <== NOT EXECUTED 3e5dc: e1a02007 mov r2, r7 <== NOT EXECUTED 3e5e0: ebfff17f bl 3abe4 <rtems_rfs_file_set_size> <== NOT EXECUTED
if (rc)
3e5e4: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3e5e8: 0a000002 beq 3e5f8 <rtems_rfs_rtems_file_ftruncate+0x54> <== NOT EXECUTED
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
3e5ec: eb00127f bl 42ff0 <__errno> <== NOT EXECUTED 3e5f0: e5806000 str r6, [r0] <== NOT EXECUTED 3e5f4: e3e06000 mvn r6, #0 <== NOT EXECUTED
iop->size = rtems_rfs_file_size (file);
3e5f8: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3e5fc: e2831084 add r1, r3, #132 ; 0x84 <== NOT EXECUTED 3e600: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3e604: ebffe8ac bl 388bc <rtems_rfs_block_get_size> <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
3e608: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3e60c: e5933098 ldr r3, [r3, #152] ; 0x98 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e610: e593407c ldr r4, [r3, #124] ; 0x7c <== NOT EXECUTED
rc = rtems_rfs_file_set_size (file, length);
if (rc)
rc = rtems_rfs_rtems_error ("file_ftruncate: set size", rc);
iop->size = rtems_rfs_file_size (file);
3e614: e9850003 stmib r5, {r0, r1} <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e618: e1a00003 mov r0, r3 <== NOT EXECUTED 3e61c: ebffec6c bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
3e620: e5940000 ldr r0, [r4] <== NOT EXECUTED 3e624: ebff37ee bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rc;
}
3e628: e1a00006 mov r0, r6 <== NOT EXECUTED
3e62c: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
0003e40c <rtems_rfs_rtems_file_ioctl>:
int
rtems_rfs_rtems_file_ioctl (rtems_libio_t* iop, uint32_t command, void* buffer)
{
return 0;
}
3e40c: e3a00000 mov r0, #0 <== NOT EXECUTED 3e410: e12fff1e bx lr <== NOT EXECUTED
0003e7f0 <rtems_rfs_rtems_file_lseek>:
*/
rtems_off64_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
3e7f0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
rtems_rfs_file_handle* file = iop->file_info;
3e7f4: e5904038 ldr r4, [r0, #56] ; 0x38 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
3e7f8: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3e7fc: e5933098 ldr r3, [r3, #152] ; 0x98 <== NOT EXECUTED 3e800: e593307c ldr r3, [r3, #124] ; 0x7c <== NOT EXECUTED 3e804: e3a01000 mov r1, #0 <== NOT EXECUTED
*/
rtems_off64_t
rtems_rfs_rtems_file_lseek (rtems_libio_t* iop,
rtems_off64_t offset,
int whence)
{
3e808: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 3e80c: e1a05000 mov r5, r0 <== NOT EXECUTED 3e810: e1a02001 mov r2, r1 <== NOT EXECUTED 3e814: e5930000 ldr r0, [r3] <== NOT EXECUTED 3e818: ebff3729 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_LSEEK))
printf("rtems-rfs: file-lseek: handle:%p offset:%Ld\n", file, offset);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
3e81c: e285200c add r2, r5, #12 <== NOT EXECUTED
3e820: e8920006 ldm r2, {r1, r2} <== NOT EXECUTED
3e824: e28d3008 add r3, sp, #8 <== NOT EXECUTED
3e828: e9230006 stmdb r3!, {r1, r2} <== NOT EXECUTED
rc = rtems_rfs_file_seek (file, pos, &pos);
3e82c: e1a00004 mov r0, r4 <== NOT EXECUTED 3e830: e1a0300d mov r3, sp <== NOT EXECUTED 3e834: ebfff1b1 bl 3af00 <rtems_rfs_file_seek> <== NOT EXECUTED
if (rc)
3e838: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3e83c: 0a00000d beq 3e878 <rtems_rfs_rtems_file_lseek+0x88> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
3e840: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3e844: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e848: e590407c ldr r4, [r0, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e84c: ebffebe0 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
3e850: e5940000 ldr r0, [r4] <== NOT EXECUTED 3e854: ebff3762 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
3e858: eb0011e4 bl 42ff0 <__errno> <== NOT EXECUTED 3e85c: e5806000 str r6, [r0] <== NOT EXECUTED 3e860: e3e03000 mvn r3, #0 <== NOT EXECUTED 3e864: e3e04000 mvn r4, #0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return iop->offset;
}
3e868: e1a01004 mov r1, r4 <== NOT EXECUTED
3e86c: e1a00003 mov r0, r3 <== NOT EXECUTED
3e870: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3e874: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file_lseek: lseek", rc);
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
3e878: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3e87c: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e880: e590407c ldr r4, [r0, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e884: ebffebd2 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 3e888: e5940000 ldr r0, [r4] <== NOT EXECUTED 3e88c: ebff3754 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return iop->offset;
3e890: e285400c add r4, r5, #12 <== NOT EXECUTED
3e894: e8940018 ldm r4, {r3, r4} <== NOT EXECUTED
3e898: eafffff2 b 3e868 <rtems_rfs_rtems_file_lseek+0x78> <== NOT EXECUTED
0003e89c <rtems_rfs_rtems_file_open>:
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
3e89c: e5903028 ldr r3, [r0, #40] ; 0x28 <== NOT EXECUTED
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
3e8a0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (&iop->pathinfo);
3e8a4: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
3e8a8: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED 3e8ac: e3a01000 mov r1, #0 <== NOT EXECUTED
static int
rtems_rfs_rtems_file_open (rtems_libio_t* iop,
const char* pathname,
uint32_t flag,
uint32_t mode)
{
3e8b0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3e8b4: e1a02001 mov r2, r1 <== NOT EXECUTED 3e8b8: e1a05000 mov r5, r0 <== NOT EXECUTED 3e8bc: e5930000 ldr r0, [r3] <== NOT EXECUTED 3e8c0: ebff36ff bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_rfs_rtems_lock (fs);
ino = rtems_rfs_rtems_get_iop_ino (iop);
rc = rtems_rfs_file_open (fs, ino, flags, &file);
3e8c4: e1a00004 mov r0, r4 <== NOT EXECUTED 3e8c8: e5951038 ldr r1, [r5, #56] ; 0x38 <== NOT EXECUTED 3e8cc: e3a02000 mov r2, #0 <== NOT EXECUTED 3e8d0: e1a0300d mov r3, sp <== NOT EXECUTED 3e8d4: ebfff29c bl 3b34c <rtems_rfs_file_open> <== NOT EXECUTED
if (rc > 0)
3e8d8: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3e8dc: da000009 ble 3e908 <rtems_rfs_rtems_file_open+0x6c> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e8e0: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e8e4: e1a00004 mov r0, r4 <== NOT EXECUTED 3e8e8: ebffebb9 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
3e8ec: e5950000 ldr r0, [r5] <== NOT EXECUTED 3e8f0: ebff373b bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("file-open: open", rc);
3e8f4: eb0011bd bl 42ff0 <__errno> <== NOT EXECUTED 3e8f8: e5806000 str r6, [r0] <== NOT EXECUTED 3e8fc: e3e00000 mvn r0, #0 <== NOT EXECUTED
iop->size = rtems_rfs_file_size (file);
iop->file_info = file;
rtems_rfs_rtems_unlock (fs);
return 0;
}
3e900: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3e904: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
iop->size = rtems_rfs_file_size (file);
3e908: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3e90c: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 3e910: e2831084 add r1, r3, #132 ; 0x84 <== NOT EXECUTED 3e914: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3e918: ebffe7e7 bl 388bc <rtems_rfs_block_get_size> <== NOT EXECUTED
iop->file_info = file;
3e91c: e59d3000 ldr r3, [sp] <== NOT EXECUTED 3e920: e5853038 str r3, [r5, #56] ; 0x38 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e924: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
}
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_OPEN))
printf("rtems-rfs: file-open: handle:%p\n", file);
iop->size = rtems_rfs_file_size (file);
3e928: e9850003 stmib r5, {r0, r1} <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e92c: e1a00004 mov r0, r4 <== NOT EXECUTED 3e930: ebffeba7 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 3e934: e5960000 ldr r0, [r6] <== NOT EXECUTED 3e938: ebff3729 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 3e93c: e3a00000 mov r0, #0 <== NOT EXECUTED 3e940: eaffffee b 3e900 <rtems_rfs_rtems_file_open+0x64> <== NOT EXECUTED
0003e414 <rtems_rfs_rtems_file_read>:
*/
ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
3e414: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
rtems_rfs_file_handle* file = iop->file_info;
3e418: e5904038 ldr r4, [r0, #56] ; 0x38 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
3e41c: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3e420: e5933098 ldr r3, [r3, #152] ; 0x98 <== NOT EXECUTED 3e424: e593307c ldr r3, [r3, #124] ; 0x7c <== NOT EXECUTED
*/
ssize_t
rtems_rfs_rtems_file_read (rtems_libio_t* iop,
void* buffer,
size_t count)
{
3e428: e1a07001 mov r7, r1 <== NOT EXECUTED 3e42c: e3a01000 mov r1, #0 <== NOT EXECUTED 3e430: e1a05000 mov r5, r0 <== NOT EXECUTED 3e434: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3e438: e5930000 ldr r0, [r3] <== NOT EXECUTED 3e43c: e1a06002 mov r6, r2 <== NOT EXECUTED 3e440: e1a02001 mov r2, r1 <== NOT EXECUTED 3e444: ebff381e bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
3e448: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3e44c: e2831084 add r1, r3, #132 ; 0x84 <== NOT EXECUTED 3e450: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_READ))
printf("rtems-rfs: file-read: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
3e454: e285500c add r5, r5, #12 <== NOT EXECUTED
3e458: e8950120 ldm r5, {r5, r8} <== NOT EXECUTED
3e45c: ebffe916 bl 388bc <rtems_rfs_block_get_size> <== NOT EXECUTED
if (pos < rtems_rfs_file_size (file))
3e460: e1510008 cmp r1, r8 <== NOT EXECUTED 3e464: 9a00002d bls 3e520 <rtems_rfs_rtems_file_read+0x10c> <== NOT EXECUTED
{
while (count)
3e468: e3560000 cmp r6, #0 <== NOT EXECUTED
void* buffer,
size_t count)
{
rtems_rfs_file_handle* file = iop->file_info;
rtems_rfs_pos pos;
uint8_t* data = buffer;
3e46c: 13a08000 movne r8, #0 <== NOT EXECUTED 3e470: 11a0a00d movne sl, sp <== NOT EXECUTED
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
3e474: 1a000004 bne 3e48c <rtems_rfs_rtems_file_read+0x78> <== NOT EXECUTED 3e478: ea00002b b 3e52c <rtems_rfs_rtems_file_read+0x118> <== NOT EXECUTED 3e47c: e0566005 subs r6, r6, r5 <== NOT EXECUTED
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
count -= size;
read += size;
3e480: e0888005 add r8, r8, r5 <== NOT EXECUTED
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
{
while (count)
3e484: 0a00001c beq 3e4fc <rtems_rfs_rtems_file_read+0xe8> <== NOT EXECUTED
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
3e488: e0877005 add r7, r7, r5 <== NOT EXECUTED
{
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
3e48c: e1a0100d mov r1, sp <== NOT EXECUTED 3e490: e1a00004 mov r0, r4 <== NOT EXECUTED 3e494: e3a02001 mov r2, #1 <== NOT EXECUTED 3e498: ebfff16f bl 3aa5c <rtems_rfs_file_io_start> <== NOT EXECUTED
if (rc > 0)
3e49c: e2505000 subs r5, r0, #0 <== NOT EXECUTED
break;
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
3e4a0: e1a00007 mov r0, r7 <== NOT EXECUTED
while (count)
{
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
if (rc > 0)
3e4a4: ca000022 bgt 3e534 <rtems_rfs_rtems_file_read+0x120> <== NOT EXECUTED
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
break;
}
if (size == 0)
3e4a8: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3e4ac: e3520000 cmp r2, #0 <== NOT EXECUTED 3e4b0: 0a000011 beq 3e4fc <rtems_rfs_rtems_file_read+0xe8> <== NOT EXECUTED
break;
if (size > count)
3e4b4: e1520006 cmp r2, r6 <== NOT EXECUTED
size = count;
3e4b8: 858d6000 strhi r6, [sp] <== NOT EXECUTED
memcpy (data, rtems_rfs_file_data (file), size);
3e4bc: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 3e4c0: e5931020 ldr r1, [r3, #32] <== NOT EXECUTED 3e4c4: e5943014 ldr r3, [r4, #20] <== NOT EXECUTED
if (size == 0)
break;
if (size > count)
size = count;
3e4c8: 81a02006 movhi r2, r6 <== NOT EXECUTED
memcpy (data, rtems_rfs_file_data (file), size);
3e4cc: e0811003 add r1, r1, r3 <== NOT EXECUTED 3e4d0: eb001f76 bl 462b0 <memcpy> <== NOT EXECUTED
data += size;
3e4d4: e59d5000 ldr r5, [sp] <== NOT EXECUTED
count -= size;
read += size;
rc = rtems_rfs_file_io_end (file, size, true);
3e4d8: e1a00004 mov r0, r4 <== NOT EXECUTED 3e4dc: e1a01005 mov r1, r5 <== NOT EXECUTED 3e4e0: e3a02001 mov r2, #1 <== NOT EXECUTED 3e4e4: ebfff2ba bl 3afd4 <rtems_rfs_file_io_end> <== NOT EXECUTED
if (rc > 0)
3e4e8: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3e4ec: daffffe2 ble 3e47c <rtems_rfs_rtems_file_read+0x68> <== NOT EXECUTED
{
read = rtems_rfs_rtems_error ("file-read: read: io-end", rc);
3e4f0: eb0012be bl 42ff0 <__errno> <== NOT EXECUTED 3e4f4: e5809000 str r9, [r0] <== NOT EXECUTED 3e4f8: e3e08000 mvn r8, #0 <== NOT EXECUTED
break;
}
}
}
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
3e4fc: e594301c ldr r3, [r4, #28] <== NOT EXECUTED 3e500: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e504: e590407c ldr r4, [r0, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e508: ebffecb1 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
3e50c: e5940000 ldr r0, [r4] <== NOT EXECUTED 3e510: ebff3833 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return read;
}
3e514: e1a00008 mov r0, r8 <== NOT EXECUTED
3e518: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3e51c: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
if (pos < rtems_rfs_file_size (file))
3e520: 1a000001 bne 3e52c <rtems_rfs_rtems_file_read+0x118> <== NOT EXECUTED 3e524: e1500005 cmp r0, r5 <== NOT EXECUTED 3e528: 8affffce bhi 3e468 <rtems_rfs_rtems_file_read+0x54> <== NOT EXECUTED
if (size > count)
size = count;
memcpy (data, rtems_rfs_file_data (file), size);
data += size;
3e52c: e3a08000 mov r8, #0 <== NOT EXECUTED 3e530: eafffff1 b 3e4fc <rtems_rfs_rtems_file_read+0xe8> <== NOT EXECUTED
size_t size;
rc = rtems_rfs_file_io_start (file, &size, true);
if (rc > 0)
{
read = rtems_rfs_rtems_error ("file-read: read: io-start", rc);
3e534: eb0012ad bl 42ff0 <__errno> <== NOT EXECUTED 3e538: e3e08000 mvn r8, #0 <== NOT EXECUTED 3e53c: e5805000 str r5, [r0] <== NOT EXECUTED 3e540: eaffffed b 3e4fc <rtems_rfs_rtems_file_read+0xe8> <== NOT EXECUTED
0003e630 <rtems_rfs_rtems_file_write>:
*/
ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
3e630: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
rtems_rfs_file_handle* file = iop->file_info;
3e634: e5905038 ldr r5, [r0, #56] ; 0x38 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
3e638: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3e63c: e5933098 ldr r3, [r3, #152] ; 0x98 <== NOT EXECUTED 3e640: e593307c ldr r3, [r3, #124] ; 0x7c <== NOT EXECUTED
*/
ssize_t
rtems_rfs_rtems_file_write (rtems_libio_t* iop,
const void* buffer,
size_t count)
{
3e644: e1a07001 mov r7, r1 <== NOT EXECUTED 3e648: e3a01000 mov r1, #0 <== NOT EXECUTED 3e64c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 3e650: e1a09000 mov r9, r0 <== NOT EXECUTED 3e654: e1a04002 mov r4, r2 <== NOT EXECUTED 3e658: e5930000 ldr r0, [r3] <== NOT EXECUTED 3e65c: e1a02001 mov r2, r1 <== NOT EXECUTED 3e660: ebff3797 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
* size of file we are still past the end of the file as positions number
* from 0. For a specific position we need a file that has a length of one
* more.
*/
if (pos >= rtems_rfs_file_size (file))
3e664: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3e668: e2831084 add r1, r3, #132 ; 0x84 <== NOT EXECUTED 3e66c: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_FILE_WRITE))
printf("rtems-rfs: file-write: handle:%p count:%zd\n", file, count);
rtems_rfs_rtems_lock (rtems_rfs_file_fs (file));
pos = iop->offset;
3e670: e289b00c add fp, r9, #12 <== NOT EXECUTED
3e674: e89b0c00 ldm fp, {sl, fp} <== NOT EXECUTED
3e678: ebffe88f bl 388bc <rtems_rfs_block_get_size> <== NOT EXECUTED
* size of file we are still past the end of the file as positions number
* from 0. For a specific position we need a file that has a length of one
* more.
*/
if (pos >= rtems_rfs_file_size (file))
3e67c: e151000b cmp r1, fp <== NOT EXECUTED 3e680: 8a000008 bhi 3e6a8 <rtems_rfs_rtems_file_write+0x78> <== NOT EXECUTED 3e684: 0a000041 beq 3e790 <rtems_rfs_rtems_file_write+0x160> <== NOT EXECUTED
{
rc = rtems_rfs_file_set_size (file, pos + 1);
3e688: e3a01001 mov r1, #1 <== NOT EXECUTED 3e68c: e091100a adds r1, r1, sl <== NOT EXECUTED 3e690: e3a02000 mov r2, #0 <== NOT EXECUTED 3e694: e0a2200b adc r2, r2, fp <== NOT EXECUTED 3e698: e1a00005 mov r0, r5 <== NOT EXECUTED 3e69c: ebfff150 bl 3abe4 <rtems_rfs_file_set_size> <== NOT EXECUTED
if (rc)
3e6a0: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3e6a4: 1a000043 bne 3e7b8 <rtems_rfs_rtems_file_write+0x188> <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return rtems_rfs_rtems_error ("file-write: write extend", rc);
}
}
rtems_rfs_file_set_bpos (file, pos);
3e6a8: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3e6ac: e1a0100a mov r1, sl <== NOT EXECUTED 3e6b0: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3e6b4: e1a0200b mov r2, fp <== NOT EXECUTED 3e6b8: e2853010 add r3, r5, #16 <== NOT EXECUTED 3e6bc: ebffe84f bl 38800 <rtems_rfs_block_get_bpos> <== NOT EXECUTED
while (count)
3e6c0: e3540000 cmp r4, #0 <== NOT EXECUTED
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
3e6c4: 01a08004 moveq r8, r4 <== NOT EXECUTED
}
}
rtems_rfs_file_set_bpos (file, pos);
while (count)
3e6c8: 0a000021 beq 3e754 <rtems_rfs_rtems_file_write+0x124> <== NOT EXECUTED
const void* buffer,
size_t count)
{
rtems_rfs_file_handle* file = iop->file_info;
rtems_rfs_pos pos;
const uint8_t* data = buffer;
3e6cc: e3a08000 mov r8, #0 <== NOT EXECUTED 3e6d0: e1a0a00d mov sl, sp <== NOT EXECUTED 3e6d4: ea000003 b 3e6e8 <rtems_rfs_rtems_file_write+0xb8> <== NOT EXECUTED
}
}
rtems_rfs_file_set_bpos (file, pos);
while (count)
3e6d8: e0544006 subs r4, r4, r6 <== NOT EXECUTED
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
count -= size;
write += size;
3e6dc: e0888006 add r8, r8, r6 <== NOT EXECUTED
}
}
rtems_rfs_file_set_bpos (file, pos);
while (count)
3e6e0: 0a00001b beq 3e754 <rtems_rfs_rtems_file_write+0x124> <== NOT EXECUTED
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
data += size;
3e6e4: e0877006 add r7, r7, r6 <== NOT EXECUTED
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
3e6e8: e1a0100d mov r1, sp <== NOT EXECUTED 3e6ec: e1a00005 mov r0, r5 <== NOT EXECUTED 3e6f0: e3a02000 mov r2, #0 <== NOT EXECUTED
rtems_rfs_file_set_bpos (file, pos);
while (count)
{
size_t size = count;
3e6f4: e58d4000 str r4, [sp] <== NOT EXECUTED
rc = rtems_rfs_file_io_start (file, &size, false);
3e6f8: ebfff0d7 bl 3aa5c <rtems_rfs_file_io_start> <== NOT EXECUTED
if (rc)
3e6fc: e2506000 subs r6, r0, #0 <== NOT EXECUTED
}
if (size > count)
size = count;
memcpy (rtems_rfs_file_data (file), data, size);
3e700: e1a01007 mov r1, r7 <== NOT EXECUTED
while (count)
{
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
if (rc)
3e704: 1a000035 bne 3e7e0 <rtems_rfs_rtems_file_write+0x1b0> <== NOT EXECUTED
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
3e708: e59d2000 ldr r2, [sp] <== NOT EXECUTED 3e70c: e1520004 cmp r2, r4 <== NOT EXECUTED
size = count;
3e710: 858d4000 strhi r4, [sp] <== NOT EXECUTED
memcpy (rtems_rfs_file_data (file), data, size);
3e714: e595300c ldr r3, [r5, #12] <== NOT EXECUTED 3e718: e5930020 ldr r0, [r3, #32] <== NOT EXECUTED 3e71c: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED
write = rtems_rfs_rtems_error ("file-write: write open", rc);
break;
}
if (size > count)
size = count;
3e720: 81a02004 movhi r2, r4 <== NOT EXECUTED
memcpy (rtems_rfs_file_data (file), data, size);
3e724: e0800003 add r0, r0, r3 <== NOT EXECUTED 3e728: eb001ee0 bl 462b0 <memcpy> <== NOT EXECUTED
data += size;
3e72c: e59d6000 ldr r6, [sp] <== NOT EXECUTED
count -= size;
write += size;
rc = rtems_rfs_file_io_end (file, size, false);
3e730: e1a00005 mov r0, r5 <== NOT EXECUTED 3e734: e1a01006 mov r1, r6 <== NOT EXECUTED 3e738: e3a02000 mov r2, #0 <== NOT EXECUTED 3e73c: ebfff224 bl 3afd4 <rtems_rfs_file_io_end> <== NOT EXECUTED
if (rc)
3e740: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3e744: 0affffe3 beq 3e6d8 <rtems_rfs_rtems_file_write+0xa8> <== NOT EXECUTED
{
write = rtems_rfs_rtems_error ("file-write: write close", rc);
3e748: eb001228 bl 42ff0 <__errno> <== NOT EXECUTED 3e74c: e580b000 str fp, [r0] <== NOT EXECUTED 3e750: e3e08000 mvn r8, #0 <== NOT EXECUTED
break;
}
}
iop->size = rtems_rfs_file_size (file);
3e754: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3e758: e2831084 add r1, r3, #132 ; 0x84 <== NOT EXECUTED 3e75c: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED 3e760: ebffe855 bl 388bc <rtems_rfs_block_get_size> <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
3e764: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3e768: e5933098 ldr r3, [r3, #152] ; 0x98 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e76c: e593407c ldr r4, [r3, #124] ; 0x7c <== NOT EXECUTED
write = rtems_rfs_rtems_error ("file-write: write close", rc);
break;
}
}
iop->size = rtems_rfs_file_size (file);
3e770: e9890003 stmib r9, {r0, r1} <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e774: e1a00003 mov r0, r3 <== NOT EXECUTED 3e778: ebffec15 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
3e77c: e5940000 ldr r0, [r4] <== NOT EXECUTED 3e780: ebff3797 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
return write;
}
3e784: e1a00008 mov r0, r8 <== NOT EXECUTED
3e788: e28dd004 add sp, sp, #4 <== NOT EXECUTED
3e78c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
* size of file we are still past the end of the file as positions number
* from 0. For a specific position we need a file that has a length of one
* more.
*/
if (pos >= rtems_rfs_file_size (file))
3e790: e150000a cmp r0, sl <== NOT EXECUTED 3e794: 8affffc3 bhi 3e6a8 <rtems_rfs_rtems_file_write+0x78> <== NOT EXECUTED
{
rc = rtems_rfs_file_set_size (file, pos + 1);
3e798: e3a01001 mov r1, #1 <== NOT EXECUTED 3e79c: e091100a adds r1, r1, sl <== NOT EXECUTED 3e7a0: e3a02000 mov r2, #0 <== NOT EXECUTED 3e7a4: e0a2200b adc r2, r2, fp <== NOT EXECUTED 3e7a8: e1a00005 mov r0, r5 <== NOT EXECUTED 3e7ac: ebfff10c bl 3abe4 <rtems_rfs_file_set_size> <== NOT EXECUTED
if (rc)
3e7b0: e2506000 subs r6, r0, #0 <== NOT EXECUTED 3e7b4: 0affffbb beq 3e6a8 <rtems_rfs_rtems_file_write+0x78> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (rtems_rfs_file_fs (file));
3e7b8: e595301c ldr r3, [r5, #28] <== NOT EXECUTED 3e7bc: e5930098 ldr r0, [r3, #152] ; 0x98 <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
3e7c0: e590407c ldr r4, [r0, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
3e7c4: ebffec02 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 3e7c8: e5940000 ldr r0, [r4] <== NOT EXECUTED 3e7cc: ebff3784 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return rtems_rfs_rtems_error ("file-write: write extend", rc);
3e7d0: eb001206 bl 42ff0 <__errno> <== NOT EXECUTED 3e7d4: e3e08000 mvn r8, #0 <== NOT EXECUTED 3e7d8: e5806000 str r6, [r0] <== NOT EXECUTED 3e7dc: eaffffe8 b 3e784 <rtems_rfs_rtems_file_write+0x154> <== NOT EXECUTED
size_t size = count;
rc = rtems_rfs_file_io_start (file, &size, false);
if (rc)
{
write = rtems_rfs_rtems_error ("file-write: write open", rc);
3e7e0: eb001202 bl 42ff0 <__errno> <== NOT EXECUTED 3e7e4: e3e08000 mvn r8, #0 <== NOT EXECUTED 3e7e8: e5806000 str r6, [r0] <== NOT EXECUTED 3e7ec: eaffffd8 b 3e754 <rtems_rfs_rtems_file_write+0x124> <== NOT EXECUTED
00021108 <rtems_rfs_rtems_freenodinfo>:
int
rtems_rfs_rtems_freenodinfo (rtems_filesystem_location_info_t* pathloc)
{
return 0;
}
21108: e3a00000 mov r0, #0 <== NOT EXECUTED 2110c: e12fff1e bx lr <== NOT EXECUTED
00022914 <rtems_rfs_rtems_imode>:
return true;
}
uint16_t
rtems_rfs_rtems_imode (mode_t mode)
{
22914: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED
/* * Mapping matches RTEMS so no need to change. */ return mode; }
22918: e1a00820 lsr r0, r0, #16 <== NOT EXECUTED 2291c: e12fff1e bx lr <== NOT EXECUTED
00021170 <rtems_rfs_rtems_initialise>:
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
21170: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
21174: e2514000 subs r4, r1, #0 <== NOT EXECUTED
*/
int
rtems_rfs_rtems_initialise (rtems_filesystem_mount_table_entry_t* mt_entry,
const void* data)
{
21178: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 2117c: e1a05000 mov r5, r0 <== NOT EXECUTED
int rc;
/*
* Parse the options the user specifiies.
*/
while (options)
21180: 01a06004 moveq r6, r4 <== NOT EXECUTED 21184: 03a07005 moveq r7, #5 <== NOT EXECUTED 21188: 0a000025 beq 21224 <rtems_rfs_rtems_initialise+0xb4> <== NOT EXECUTED 2118c: e3a07005 mov r7, #5 <== NOT EXECUTED 21190: e3a06000 mov r6, #0 <== NOT EXECUTED
{
printf ("options=%s\n", options);
21194: e1a01004 mov r1, r4 <== NOT EXECUTED 21198: e59f0190 ldr r0, [pc, #400] ; 21330 <rtems_rfs_rtems_initialise+0x1c0><== NOT EXECUTED 2119c: eb0098f1 bl 47568 <printf> <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
211a0: e59f118c ldr r1, [pc, #396] ; 21334 <rtems_rfs_rtems_initialise+0x1c4><== NOT EXECUTED 211a4: e3a0200c mov r2, #12 <== NOT EXECUTED 211a8: e1a00004 mov r0, r4 <== NOT EXECUTED 211ac: eb00a2d6 bl 49d0c <strncmp> <== NOT EXECUTED 211b0: e3500000 cmp r0, #0 <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
211b4: e59f117c ldr r1, [pc, #380] ; 21338 <rtems_rfs_rtems_initialise+0x1c8><== NOT EXECUTED 211b8: e3a0200e mov r2, #14 <== NOT EXECUTED 211bc: e1a00004 mov r0, r4 <== NOT EXECUTED
while (options)
{
printf ("options=%s\n", options);
if (strncmp (options, "hold-bitmaps",
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
211c0: 03866001 orreq r6, r6, #1 <== NOT EXECUTED
* Parse the options the user specifiies.
*/
while (options)
{
printf ("options=%s\n", options);
if (strncmp (options, "hold-bitmaps",
211c4: 0a00000d beq 21200 <rtems_rfs_rtems_initialise+0x90> <== NOT EXECUTED
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
211c8: eb00a2cf bl 49d0c <strncmp> <== NOT EXECUTED 211cc: e3500000 cmp r0, #0 <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
211d0: e59f1164 ldr r1, [pc, #356] ; 2133c <rtems_rfs_rtems_initialise+0x1cc><== NOT EXECUTED 211d4: e3a0200d mov r2, #13 <== NOT EXECUTED 211d8: e1a00004 mov r0, r4 <== NOT EXECUTED
if (strncmp (options, "hold-bitmaps",
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
211dc: 03866002 orreq r6, r6, #2 <== NOT EXECUTED
{
printf ("options=%s\n", options);
if (strncmp (options, "hold-bitmaps",
sizeof ("hold-bitmaps") - 1) == 0)
flags |= RTEMS_RFS_FS_BITMAPS_HOLD;
else if (strncmp (options, "no-local-cache",
211e0: 0a000006 beq 21200 <rtems_rfs_rtems_initialise+0x90> <== NOT EXECUTED
sizeof ("no-local-cache") - 1) == 0)
flags |= RTEMS_RFS_FS_NO_LOCAL_CACHE;
else if (strncmp (options, "max-held-bufs",
211e4: eb00a2c8 bl 49d0c <strncmp> <== NOT EXECUTED 211e8: e2501000 subs r1, r0, #0 <== NOT EXECUTED 211ec: 1a00003a bne 212dc <rtems_rfs_rtems_initialise+0x16c> <== NOT EXECUTED
sizeof ("max-held-bufs") - 1) == 0)
{
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
211f0: e284000e add r0, r4, #14 <== NOT EXECUTED 211f4: e1a02001 mov r2, r1 <== NOT EXECUTED 211f8: eb00a795 bl 4b054 <strtoul> <== NOT EXECUTED 211fc: e1a07000 mov r7, r0 <== NOT EXECUTED
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
options = strchr (options, ',');
21200: e1a00004 mov r0, r4 <== NOT EXECUTED 21204: e3a0102c mov r1, #44 ; 0x2c <== NOT EXECUTED 21208: eb009fa6 bl 490a8 <strchr> <== NOT EXECUTED
if (options)
2120c: e3500000 cmp r0, #0 <== NOT EXECUTED 21210: 0a000003 beq 21224 <rtems_rfs_rtems_initialise+0xb4> <== NOT EXECUTED
{
++options;
if (*options == '\0')
21214: e5d03001 ldrb r3, [r0, #1] <== NOT EXECUTED 21218: e3530000 cmp r3, #0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
options = strchr (options, ',');
if (options)
{
++options;
2121c: e2804001 add r4, r0, #1 <== NOT EXECUTED
if (*options == '\0')
21220: 1affffdb bne 21194 <rtems_rfs_rtems_initialise+0x24> <== NOT EXECUTED
options = NULL;
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
21224: e3a00004 mov r0, #4 <== NOT EXECUTED 21228: ebff9c94 bl 8480 <malloc> <== NOT EXECUTED
if (!rtems)
2122c: e2504000 subs r4, r0, #0 <== NOT EXECUTED 21230: 0a000039 beq 2131c <rtems_rfs_rtems_initialise+0x1ac> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
memset (rtems, 0, sizeof (rtems_rfs_rtems_private));
21234: e3a08000 mov r8, #0 <== NOT EXECUTED 21238: e5848000 str r8, [r4] <== NOT EXECUTED
rc = rtems_rfs_mutex_create (&rtems->access);
2123c: eb0072ea bl 3ddec <rtems_rfs_mutex_create> <== NOT EXECUTED
if (rc > 0)
21240: e250a000 subs sl, r0, #0 <== NOT EXECUTED 21244: da000006 ble 21264 <rtems_rfs_rtems_initialise+0xf4> <== NOT EXECUTED
{
free (rtems);
21248: e1a00004 mov r0, r4 <== NOT EXECUTED 2124c: ebff9ac7 bl 7d70 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot create mutex", rc);
21250: eb008766 bl 42ff0 <__errno> <== NOT EXECUTED 21254: e580a000 str sl, [r0] <== NOT EXECUTED 21258: e3e00000 mvn r0, #0 <== NOT EXECUTED
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
rtems_rfs_rtems_unlock (fs);
return 0;
}
2125c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
21260: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
21264: e1a01008 mov r1, r8 <== NOT EXECUTED 21268: e5940000 ldr r0, [r4] <== NOT EXECUTED 2126c: e1a02008 mov r2, r8 <== NOT EXECUTED 21270: ebffac93 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL)
21274: e3500000 cmp r0, #0 <== NOT EXECUTED 21278: 1a00000e bne 212b8 <rtems_rfs_rtems_initialise+0x148> <== NOT EXECUTED
rtems_rfs_mutex_destroy (&rtems->access);
free (rtems);
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
}
rc = rtems_rfs_fs_open (mt_entry->dev, rtems, flags, max_held_buffers, &fs);
2127c: e5950070 ldr r0, [r5, #112] ; 0x70 <== NOT EXECUTED 21280: e1a02006 mov r2, r6 <== NOT EXECUTED 21284: e28dc004 add ip, sp, #4 <== NOT EXECUTED 21288: e1a03007 mov r3, r7 <== NOT EXECUTED 2128c: e1a01004 mov r1, r4 <== NOT EXECUTED 21290: e58dc000 str ip, [sp] <== NOT EXECUTED 21294: eb0068ea bl 3b644 <rtems_rfs_fs_open> <== NOT EXECUTED
if (rc)
21298: e2506000 subs r6, r0, #0 <== NOT EXECUTED 2129c: 0a000013 beq 212f0 <rtems_rfs_rtems_initialise+0x180> <== NOT EXECUTED
{
free (rtems);
212a0: e1a00004 mov r0, r4 <== NOT EXECUTED 212a4: ebff9ab1 bl 7d70 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
212a8: eb008750 bl 42ff0 <__errno> <== NOT EXECUTED 212ac: e5806000 str r6, [r0] <== NOT EXECUTED 212b0: e3e00000 mvn r0, #0 <== NOT EXECUTED 212b4: eaffffe8 b 2125c <rtems_rfs_rtems_initialise+0xec> <== NOT EXECUTED
}
rc = rtems_rfs_mutex_lock (&rtems->access);
if (rc > 0)
{
rtems_rfs_mutex_destroy (&rtems->access);
212b8: e1a00004 mov r0, r4 <== NOT EXECUTED 212bc: eb0072c3 bl 3ddd0 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
free (rtems);
212c0: e1a00004 mov r0, r4 <== NOT EXECUTED 212c4: ebff9aa9 bl 7d70 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: cannot lock access mutex", rc);
212c8: eb008748 bl 42ff0 <__errno> <== NOT EXECUTED 212cc: e3a03005 mov r3, #5 <== NOT EXECUTED 212d0: e5803000 str r3, [r0] <== NOT EXECUTED 212d4: e3e00000 mvn r0, #0 <== NOT EXECUTED 212d8: eaffffdf b 2125c <rtems_rfs_rtems_initialise+0xec> <== NOT EXECUTED
sizeof ("max-held-bufs") - 1) == 0)
{
max_held_buffers = strtoul (options + sizeof ("max-held-bufs"), 0, 0);
}
else
return rtems_rfs_rtems_error ("initialise: invalid option", EINVAL);
212dc: eb008743 bl 42ff0 <__errno> <== NOT EXECUTED 212e0: e3a03016 mov r3, #22 <== NOT EXECUTED 212e4: e5803000 str r3, [r0] <== NOT EXECUTED 212e8: e3e00000 mvn r0, #0 <== NOT EXECUTED 212ec: eaffffda b 2125c <rtems_rfs_rtems_initialise+0xec> <== NOT EXECUTED
mt_entry->fs_info = fs;
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
212f0: e59f3048 ldr r3, [pc, #72] ; 21340 <rtems_rfs_rtems_initialise+0x1d0><== NOT EXECUTED 212f4: e5853028 str r3, [r5, #40] ; 0x28 <== NOT EXECUTED
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
212f8: e3a03001 mov r3, #1 <== NOT EXECUTED
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
212fc: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
21300: e585301c str r3, [r5, #28] <== NOT EXECUTED
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
21304: e59f3038 ldr r3, [pc, #56] ; 21344 <rtems_rfs_rtems_initialise+0x1d4><== NOT EXECUTED
{
free (rtems);
return rtems_rfs_rtems_error ("initialise: open", rc);
}
mt_entry->fs_info = fs;
21308: e5850034 str r0, [r5, #52] ; 0x34 <== NOT EXECUTED
mt_entry->mt_fs_root.node_access = (void*) RTEMS_RFS_ROOT_INO;
mt_entry->mt_fs_root.handlers = &rtems_rfs_rtems_dir_handlers;
2130c: e5853024 str r3, [r5, #36] ; 0x24 <== NOT EXECUTED
mt_entry->mt_fs_root.ops = &rtems_rfs_ops;
rtems_rfs_rtems_unlock (fs);
21310: ebffff80 bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED 21314: e1a00006 mov r0, r6 <== NOT EXECUTED
return 0;
21318: eaffffcf b 2125c <rtems_rfs_rtems_initialise+0xec> <== NOT EXECUTED
}
}
rtems = malloc (sizeof (rtems_rfs_rtems_private));
if (!rtems)
return rtems_rfs_rtems_error ("initialise: local data", ENOMEM);
2131c: eb008733 bl 42ff0 <__errno> <== NOT EXECUTED 21320: e3a0300c mov r3, #12 <== NOT EXECUTED 21324: e5803000 str r3, [r0] <== NOT EXECUTED 21328: e3e00000 mvn r0, #0 <== NOT EXECUTED 2132c: eaffffca b 2125c <rtems_rfs_rtems_initialise+0xec> <== NOT EXECUTED
000219e4 <rtems_rfs_rtems_link>:
*/
int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
219e4: e1a03000 mov r3, r0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);
219e8: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
*/
int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
219ec: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc);
219f0: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
219f4: e594007c ldr r0, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_ino target = rtems_rfs_rtems_get_pathloc_ino (to_loc); rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
219f8: e5917000 ldr r7, [r1] <== NOT EXECUTED 219fc: e3a01000 mov r1, #0 <== NOT EXECUTED
*/
int
rtems_rfs_rtems_link (rtems_filesystem_location_info_t* to_loc,
rtems_filesystem_location_info_t* parent_loc,
const char* name)
{
21a00: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 21a04: e1a06002 mov r6, r2 <== NOT EXECUTED 21a08: e5900000 ldr r0, [r0] <== NOT EXECUTED 21a0c: e1a02001 mov r2, r1 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (to_loc); rtems_rfs_ino target = rtems_rfs_rtems_get_pathloc_ino (to_loc);
21a10: e5935000 ldr r5, [r3] <== NOT EXECUTED 21a14: ebffaaaa bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
printf ("rtems-rfs-rtems: link: in: parent:%" PRId32 " target:%" PRId32 "\n",
parent, target);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_link (fs, name, strlen (name), parent, target, false);
21a18: e1a00006 mov r0, r6 <== NOT EXECUTED
21a1c: eb00a070 bl 49be4 <strlen> <== NOT EXECUTED
21a20: e3a0c000 mov ip, #0 <== NOT EXECUTED
21a24: e1a02000 mov r2, r0 <== NOT EXECUTED
21a28: e1a01006 mov r1, r6 <== NOT EXECUTED
21a2c: e1a03007 mov r3, r7 <== NOT EXECUTED
21a30: e1a00004 mov r0, r4 <== NOT EXECUTED
21a34: e88d1020 stm sp, {r5, ip} <== NOT EXECUTED
21a38: eb007085 bl 3dc54 <rtems_rfs_link> <== NOT EXECUTED
if (rc)
21a3c: e2505000 subs r5, r0, #0 <== NOT EXECUTED 21a40: 0a000009 beq 21a6c <rtems_rfs_rtems_link+0x88> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
21a44: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21a48: e1a00004 mov r0, r4 <== NOT EXECUTED 21a4c: eb005f60 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
21a50: e5960000 ldr r0, [r6] <== NOT EXECUTED 21a54: ebffaae2 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("link: linking", rc);
21a58: eb008564 bl 42ff0 <__errno> <== NOT EXECUTED 21a5c: e5805000 str r5, [r0] <== NOT EXECUTED 21a60: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
21a64: e28dd008 add sp, sp, #8 <== NOT EXECUTED
21a68: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
21a6c: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21a70: e1a00004 mov r0, r4 <== NOT EXECUTED 21a74: eb005f56 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 21a78: e5960000 ldr r0, [r6] <== NOT EXECUTED 21a7c: ebffaad8 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 21a80: e1a00005 mov r0, r5 <== NOT EXECUTED
return rtems_rfs_rtems_error ("link: linking", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
21a84: eafffff6 b 21a64 <rtems_rfs_rtems_link+0x80> <== NOT EXECUTED
00022414 <rtems_rfs_rtems_mknod>:
int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
22414: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
22418: e24dd040 sub sp, sp, #64 ; 0x40 <== NOT EXECUTED
2241c: e59dc060 ldr ip, [sp, #96] ; 0x60 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
22420: e59ce010 ldr lr, [ip, #16] <== NOT EXECUTED 22424: e59e4034 ldr r4, [lr, #52] ; 0x34 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
22428: e594e07c ldr lr, [r4, #124] ; 0x7c <== NOT EXECUTED
int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
2242c: e1a06001 mov r6, r1 <== NOT EXECUTED 22430: e3a01000 mov r1, #0 <== NOT EXECUTED 22434: e1a05000 mov r5, r0 <== NOT EXECUTED 22438: e1a07002 mov r7, r2 <== NOT EXECUTED 2243c: e59e0000 ldr r0, [lr] <== NOT EXECUTED 22440: e1a02001 mov r2, r1 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc); rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (pathloc);
22444: e59ca000 ldr sl, [ip] <== NOT EXECUTED
int
rtems_rfs_rtems_mknod (const char *name,
mode_t mode,
dev_t dev,
rtems_filesystem_location_info_t *pathloc)
{
22448: e1a09003 mov r9, r3 <== NOT EXECUTED 2244c: ebffa81c bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
22450: e1a00005 mov r0, r5 <== NOT EXECUTED 22454: eb009de2 bl 49be4 <strlen> <== NOT EXECUTED 22458: e1a08000 mov r8, r0 <== NOT EXECUTED
rtems_rfs_rtems_imode (mode),
2245c: e1a00006 mov r0, r6 <== NOT EXECUTED 22460: eb00012b bl 22914 <rtems_rfs_rtems_imode> <== NOT EXECUTED
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
22464: e3a0c000 mov ip, #0 <== NOT EXECUTED
22468: e58d0000 str r0, [sp] <== NOT EXECUTED
2246c: e1a02005 mov r2, r5 <== NOT EXECUTED
22470: e1a03008 mov r3, r8 <== NOT EXECUTED
22474: e28de03c add lr, sp, #60 ; 0x3c <== NOT EXECUTED
22478: e1a0100a mov r1, sl <== NOT EXECUTED
2247c: e3a05001 mov r5, #1 <== NOT EXECUTED
22480: e1a00004 mov r0, r4 <== NOT EXECUTED
22484: e58dc00c str ip, [sp, #12] <== NOT EXECUTED
22488: e58de010 str lr, [sp, #16] <== NOT EXECUTED
2248c: e98d1020 stmib sp, {r5, ip} <== NOT EXECUTED
22490: eb006bd7 bl 3d3f4 <rtems_rfs_inode_create> <== NOT EXECUTED
rtems_rfs_rtems_imode (mode),
1, uid, gid, &ino);
if (rc > 0)
22494: e2508000 subs r8, r0, #0 <== NOT EXECUTED 22498: da000009 ble 224c4 <rtems_rfs_rtems_mknod+0xb0> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
2249c: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
224a0: e1a00004 mov r0, r4 <== NOT EXECUTED 224a4: eb005cca bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
224a8: e5950000 ldr r0, [r5] <== NOT EXECUTED 224ac: ebffa84c bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: inode create", rc);
224b0: eb0082ce bl 42ff0 <__errno> <== NOT EXECUTED 224b4: e5808000 str r8, [r0] <== NOT EXECUTED 224b8: e3e00000 mvn r0, #0 <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
224bc: e28dd040 add sp, sp, #64 ; 0x40 <== NOT EXECUTED
224c0: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: inode create", rc);
}
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
224c4: e28d8014 add r8, sp, #20 <== NOT EXECUTED 224c8: e1a00004 mov r0, r4 <== NOT EXECUTED 224cc: e59d103c ldr r1, [sp, #60] ; 0x3c <== NOT EXECUTED 224d0: e1a02008 mov r2, r8 <== NOT EXECUTED 224d4: e1a03005 mov r3, r5 <== NOT EXECUTED 224d8: eb006b61 bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
224dc: e250a000 subs sl, r0, #0 <== NOT EXECUTED 224e0: da000008 ble 22508 <rtems_rfs_rtems_mknod+0xf4> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
224e4: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
224e8: e1a00004 mov r0, r4 <== NOT EXECUTED 224ec: eb005cb8 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 224f0: e5950000 ldr r0, [r5] <== NOT EXECUTED 224f4: ebffa83a bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: inode open", rc);
224f8: eb0082bc bl 42ff0 <__errno> <== NOT EXECUTED 224fc: e580a000 str sl, [r0] <== NOT EXECUTED 22500: e3e00000 mvn r0, #0 <== NOT EXECUTED 22504: eaffffec b 224bc <rtems_rfs_rtems_mknod+0xa8> <== NOT EXECUTED
}
if (S_ISDIR(mode) || S_ISREG(mode))
22508: e2066a0f and r6, r6, #61440 ; 0xf000 <== NOT EXECUTED 2250c: e3560901 cmp r6, #16384 ; 0x4000 <== NOT EXECUTED 22510: 13560902 cmpne r6, #32768 ; 0x8000 <== NOT EXECUTED 22514: 0a000019 beq 22580 <rtems_rfs_rtems_mknod+0x16c> <== NOT EXECUTED
{
}
else if (S_ISCHR (mode) || S_ISBLK (mode))
22518: e3560a02 cmp r6, #8192 ; 0x2000 <== NOT EXECUTED 2251c: 13560a06 cmpne r6, #24576 ; 0x6000 <== NOT EXECUTED 22520: 1a000025 bne 225bc <rtems_rfs_rtems_mknod+0x1a8> <== NOT EXECUTED
* @param bno The block number.
*/
static inline void
rtems_rfs_inode_set_block (rtems_rfs_inode_handle* handle, int block, uint32_t bno)
{
rtems_rfs_write_u32 (&handle->node->data.blocks[block], bno);
22524: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 22528: e1a02c27 lsr r2, r7, #24 <== NOT EXECUTED 2252c: e5c3201c strb r2, [r3, #28] <== NOT EXECUTED 22530: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 22534: e1a02827 lsr r2, r7, #16 <== NOT EXECUTED 22538: e5c3201d strb r2, [r3, #29] <== NOT EXECUTED 2253c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 22540: e1a02427 lsr r2, r7, #8 <== NOT EXECUTED 22544: e5c3201e strb r2, [r3, #30] <== NOT EXECUTED 22548: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 2254c: e5c3701f strb r7, [r3, #31] <== NOT EXECUTED 22550: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 22554: e1a02c29 lsr r2, r9, #24 <== NOT EXECUTED 22558: e5c32020 strb r2, [r3, #32] <== NOT EXECUTED 2255c: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 22560: e1a02829 lsr r2, r9, #16 <== NOT EXECUTED 22564: e5c32021 strb r2, [r3, #33] ; 0x21 <== NOT EXECUTED 22568: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 2256c: e1a02429 lsr r2, r9, #8 <== NOT EXECUTED 22570: e5c32022 strb r2, [r3, #34] ; 0x22 <== NOT EXECUTED 22574: e59d3020 ldr r3, [sp, #32] <== NOT EXECUTED 22578: e5c39023 strb r9, [r3, #35] ; 0x23 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
2257c: e5cd5024 strb r5, [sp, #36] ; 0x24 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
}
rc = rtems_rfs_inode_close (fs, &inode);
22580: e1a01008 mov r1, r8 <== NOT EXECUTED 22584: e1a00004 mov r0, r4 <== NOT EXECUTED 22588: eb006b11 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
2258c: e2505000 subs r5, r0, #0 <== NOT EXECUTED 22590: da000005 ble 225ac <rtems_rfs_rtems_mknod+0x198> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
22594: e1a00004 mov r0, r4 <== NOT EXECUTED 22598: ebfffade bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: closing inode", rc);
2259c: eb008293 bl 42ff0 <__errno> <== NOT EXECUTED 225a0: e5805000 str r5, [r0] <== NOT EXECUTED 225a4: e3e00000 mvn r0, #0 <== NOT EXECUTED 225a8: eaffffc3 b 224bc <rtems_rfs_rtems_mknod+0xa8> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
225ac: e1a00004 mov r0, r4 <== NOT EXECUTED 225b0: ebfffad8 bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED 225b4: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
225b8: eaffffbf b 224bc <rtems_rfs_rtems_mknod+0xa8> <== NOT EXECUTED
rtems_rfs_inode_set_block (&inode, 0, major);
rtems_rfs_inode_set_block (&inode, 1, minor);
}
else
{
rtems_rfs_inode_close (fs, &inode);
225bc: e1a01008 mov r1, r8 <== NOT EXECUTED 225c0: e1a00004 mov r0, r4 <== NOT EXECUTED 225c4: eb006b02 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
225c8: e1a00004 mov r0, r4 <== NOT EXECUTED 225cc: ebfffad1 bl 21118 <rtems_rfs_rtems_unlock> <== NOT EXECUTED
return rtems_rfs_rtems_error ("mknod: bad mode", EINVAL);
225d0: eb008286 bl 42ff0 <__errno> <== NOT EXECUTED 225d4: e3a03016 mov r3, #22 <== NOT EXECUTED 225d8: e5803000 str r3, [r0] <== NOT EXECUTED 225dc: e3e00000 mvn r0, #0 <== NOT EXECUTED 225e0: eaffffb5 b 224bc <rtems_rfs_rtems_mknod+0xa8> <== NOT EXECUTED
00022920 <rtems_rfs_rtems_mode>:
{
/*
* Mapping matches RTEMS so no need to change.
*/
return imode;
}
22920: e12fff1e bx lr <== NOT EXECUTED
000227e8 <rtems_rfs_rtems_node_type>:
*/
rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
227e8: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
* @return rtems_filesystem_node_types_t
*/
rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
227ec: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
227f0: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
227f4: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
227f8: e5906000 ldr r6, [r0] <== NOT EXECUTED 227fc: e3a01000 mov r1, #0 <== NOT EXECUTED
* @return rtems_filesystem_node_types_t
*/
rtems_filesystem_node_types_t
rtems_rfs_rtems_node_type (rtems_filesystem_location_info_t* pathloc)
{
22800: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 22804: e1a02001 mov r2, r1 <== NOT EXECUTED 22808: e5930000 ldr r0, [r3] <== NOT EXECUTED 2280c: ebffa72c bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
uint16_t mode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
22810: e1a01006 mov r1, r6 <== NOT EXECUTED 22814: e1a00004 mov r0, r4 <== NOT EXECUTED 22818: e1a0200d mov r2, sp <== NOT EXECUTED 2281c: e3a03001 mov r3, #1 <== NOT EXECUTED 22820: eb006a8f bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
22824: e2506000 subs r6, r0, #0 <== NOT EXECUTED 22828: da00000a ble 22858 <rtems_rfs_rtems_node_type+0x70> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
2282c: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
22830: e1a00004 mov r0, r4 <== NOT EXECUTED 22834: eb005be6 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
22838: e5950000 ldr r0, [r5] <== NOT EXECUTED 2283c: ebffa768 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("node_type: opening inode", rc);
22840: eb0081ea bl 42ff0 <__errno> <== NOT EXECUTED 22844: e5806000 str r6, [r0] <== NOT EXECUTED 22848: e3e06000 mvn r6, #0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return type;
}
2284c: e1a00006 mov r0, r6 <== NOT EXECUTED
22850: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
22854: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
22858: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
* link is actually the normal path to a regular file, directory, device * etc's inode. Links to inodes can be considered "the real" one, yet they * are all links. */ mode = rtems_rfs_inode_get_mode (&inode); if (RTEMS_RFS_S_ISDIR (mode))
2285c: e5d33002 ldrb r3, [r3, #2] <== NOT EXECUTED 22860: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED 22864: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED 22868: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED 2286c: 03a06001 moveq r6, #1 <== NOT EXECUTED 22870: 0a000006 beq 22890 <rtems_rfs_rtems_node_type+0xa8> <== NOT EXECUTED
type = RTEMS_FILESYSTEM_DIRECTORY;
else if (RTEMS_RFS_S_ISLNK (mode))
22874: e3530a0a cmp r3, #40960 ; 0xa000 <== NOT EXECUTED 22878: 03a06004 moveq r6, #4 <== NOT EXECUTED 2287c: 0a000003 beq 22890 <rtems_rfs_rtems_node_type+0xa8> <== NOT EXECUTED
type = RTEMS_FILESYSTEM_SYM_LINK;
else if (RTEMS_RFS_S_ISBLK (mode) || RTEMS_RFS_S_ISCHR (mode))
22880: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED 22884: 13530a02 cmpne r3, #8192 ; 0x2000 <== NOT EXECUTED 22888: 03a06002 moveq r6, #2 <== NOT EXECUTED 2288c: 13a06005 movne r6, #5 <== NOT EXECUTED
type = RTEMS_FILESYSTEM_DEVICE;
else
type = RTEMS_FILESYSTEM_MEMORY_FILE;
rc = rtems_rfs_inode_close (fs, &inode);
22890: e1a0100d mov r1, sp <== NOT EXECUTED 22894: e1a00004 mov r0, r4 <== NOT EXECUTED 22898: eb006a4d bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
2289c: e2505000 subs r5, r0, #0 <== NOT EXECUTED 228a0: da000008 ble 228c8 <rtems_rfs_rtems_node_type+0xe0> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
228a4: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
228a8: e1a00004 mov r0, r4 <== NOT EXECUTED 228ac: eb005bc8 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 228b0: e5960000 ldr r0, [r6] <== NOT EXECUTED 228b4: ebffa74a bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("node_type: closing inode", rc);
228b8: eb0081cc bl 42ff0 <__errno> <== NOT EXECUTED 228bc: e3e06000 mvn r6, #0 <== NOT EXECUTED 228c0: e5805000 str r5, [r0] <== NOT EXECUTED 228c4: eaffffe0 b 2284c <rtems_rfs_rtems_node_type+0x64> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
228c8: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
228cc: e1a00004 mov r0, r4 <== NOT EXECUTED 228d0: eb005bbf bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 228d4: e5950000 ldr r0, [r5] <== NOT EXECUTED 228d8: ebffa741 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return type;
228dc: eaffffda b 2284c <rtems_rfs_rtems_node_type+0x64> <== NOT EXECUTED
00021758 <rtems_rfs_rtems_readlink>:
int
rtems_rfs_rtems_readlink (rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
21758: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
int
rtems_rfs_rtems_readlink (rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
2175c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
21760: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED 21764: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
21768: e5907000 ldr r7, [r0] <== NOT EXECUTED
int
rtems_rfs_rtems_readlink (rtems_filesystem_location_info_t* pathloc,
char* buf,
size_t bufsize)
{
2176c: e1a06001 mov r6, r1 <== NOT EXECUTED 21770: e3a01000 mov r1, #0 <== NOT EXECUTED 21774: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 21778: e1a05002 mov r5, r2 <== NOT EXECUTED 2177c: e5930000 ldr r0, [r3] <== NOT EXECUTED 21780: e1a02001 mov r2, r1 <== NOT EXECUTED 21784: ebffab4e bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_READLINK))
printf ("rtems-rfs-rtems: readlink: in: ino:%" PRId32 "\n", ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink_read (fs, ino, buf, bufsize, &length);
21788: e1a03005 mov r3, r5 <== NOT EXECUTED 2178c: e28dc004 add ip, sp, #4 <== NOT EXECUTED 21790: e1a01007 mov r1, r7 <== NOT EXECUTED 21794: e1a02006 mov r2, r6 <== NOT EXECUTED 21798: e1a00004 mov r0, r4 <== NOT EXECUTED 2179c: e58dc000 str ip, [sp] <== NOT EXECUTED 217a0: eb006fac bl 3d658 <rtems_rfs_symlink_read> <== NOT EXECUTED
if (rc)
217a4: e2505000 subs r5, r0, #0 <== NOT EXECUTED 217a8: 0a000009 beq 217d4 <rtems_rfs_rtems_readlink+0x7c> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
217ac: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
217b0: e1a00004 mov r0, r4 <== NOT EXECUTED 217b4: eb006006 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
217b8: e5960000 ldr r0, [r6] <== NOT EXECUTED 217bc: ebffab88 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("readlink: reading link", rc);
217c0: eb00860a bl 42ff0 <__errno> <== NOT EXECUTED 217c4: e5805000 str r5, [r0] <== NOT EXECUTED 217c8: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return (int) length;
}
217cc: e28dd008 add sp, sp, #8 <== NOT EXECUTED
217d0: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
217d4: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
217d8: e1a00004 mov r0, r4 <== NOT EXECUTED 217dc: eb005ffc bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 217e0: e5950000 ldr r0, [r5] <== NOT EXECUTED 217e4: ebffab7e bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
return rtems_rfs_rtems_error ("readlink: reading link", rc);
}
rtems_rfs_rtems_unlock (fs);
return (int) length;
217e8: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED 217ec: eafffff6 b 217cc <rtems_rfs_rtems_readlink+0x74> <== NOT EXECUTED
00021a88 <rtems_rfs_rtems_rename>:
int
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
rtems_filesystem_location_info_t* old_loc,
rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name)
{
21a88: e1a0c001 mov ip, r1 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
21a8c: e5911010 ldr r1, [r1, #16] <== NOT EXECUTED
int
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
rtems_filesystem_location_info_t* old_loc,
rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name)
{
21a90: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (old_loc);
21a94: e5914034 ldr r4, [r1, #52] ; 0x34 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
21a98: e594e07c ldr lr, [r4, #124] ; 0x7c <== NOT EXECUTED 21a9c: e3a01000 mov r1, #0 <== NOT EXECUTED
int
rtems_rfs_rtems_rename(rtems_filesystem_location_info_t* old_parent_loc,
rtems_filesystem_location_info_t* old_loc,
rtems_filesystem_location_info_t* new_parent_loc,
const char* new_name)
{
21aa0: e1a08003 mov r8, r3 <== NOT EXECUTED 21aa4: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
rtems_rfs_ino ino;
uint32_t doff;
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
21aa8: e592a000 ldr sl, [r2] <== NOT EXECUTED
rtems_rfs_ino new_parent;
rtems_rfs_ino ino;
uint32_t doff;
int rc;
old_parent = rtems_rfs_rtems_get_pathloc_ino (old_parent_loc);
21aac: e5907000 ldr r7, [r0] <== NOT EXECUTED 21ab0: e1a02001 mov r2, r1 <== NOT EXECUTED 21ab4: e59e0000 ldr r0, [lr] <== NOT EXECUTED
new_parent = rtems_rfs_rtems_get_pathloc_ino (new_parent_loc);
ino = rtems_rfs_rtems_get_pathloc_ino (old_loc);
21ab8: e89c0060 ldm ip, {r5, r6} <== NOT EXECUTED
21abc: ebffaa80 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
/*
* Link to the inode before unlinking so the inode is not erased when
* unlinked.
*/
rc = rtems_rfs_link (fs, new_name, strlen (new_name), new_parent, ino, true);
21ac0: e1a00008 mov r0, r8 <== NOT EXECUTED
21ac4: eb00a046 bl 49be4 <strlen> <== NOT EXECUTED
21ac8: e1a01008 mov r1, r8 <== NOT EXECUTED
21acc: e1a02000 mov r2, r0 <== NOT EXECUTED
21ad0: e3a0c001 mov ip, #1 <== NOT EXECUTED
21ad4: e1a0300a mov r3, sl <== NOT EXECUTED
21ad8: e1a00004 mov r0, r4 <== NOT EXECUTED
21adc: e88d1020 stm sp, {r5, ip} <== NOT EXECUTED
21ae0: eb00705b bl 3dc54 <rtems_rfs_link> <== NOT EXECUTED
if (rc)
21ae4: e2508000 subs r8, r0, #0 <== NOT EXECUTED 21ae8: 0a000009 beq 21b14 <rtems_rfs_rtems_rename+0x8c> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
21aec: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21af0: e1a00004 mov r0, r4 <== NOT EXECUTED 21af4: eb005f36 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
21af8: e5950000 ldr r0, [r5] <== NOT EXECUTED 21afc: ebffaab8 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("rename: linking", rc);
21b00: eb00853a bl 42ff0 <__errno> <== NOT EXECUTED 21b04: e5808000 str r8, [r0] <== NOT EXECUTED 21b08: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
21b0c: e28dd008 add sp, sp, #8 <== NOT EXECUTED
21b10: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
/*
* Unlink all inodes even directories with the dir option as false because a
* directory may not be empty.
*/
rc = rtems_rfs_unlink (fs, old_parent, ino, doff,
21b14: e1a02005 mov r2, r5 <== NOT EXECUTED 21b18: e3a0c002 mov ip, #2 <== NOT EXECUTED 21b1c: e1a01007 mov r1, r7 <== NOT EXECUTED 21b20: e1a03006 mov r3, r6 <== NOT EXECUTED 21b24: e1a00004 mov r0, r4 <== NOT EXECUTED 21b28: e58dc000 str ip, [sp] <== NOT EXECUTED 21b2c: eb006fc4 bl 3da44 <rtems_rfs_unlink> <== NOT EXECUTED
rtems_rfs_unlink_dir_allowed);
if (rc)
21b30: e2505000 subs r5, r0, #0 <== NOT EXECUTED 21b34: 0a000008 beq 21b5c <rtems_rfs_rtems_rename+0xd4> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
21b38: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21b3c: e1a00004 mov r0, r4 <== NOT EXECUTED 21b40: eb005f23 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 21b44: e5960000 ldr r0, [r6] <== NOT EXECUTED 21b48: ebffaaa5 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("rename: unlinking", rc);
21b4c: eb008527 bl 42ff0 <__errno> <== NOT EXECUTED 21b50: e5805000 str r5, [r0] <== NOT EXECUTED 21b54: e3e00000 mvn r0, #0 <== NOT EXECUTED 21b58: eaffffeb b 21b0c <rtems_rfs_rtems_rename+0x84> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
21b5c: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21b60: e1a00004 mov r0, r4 <== NOT EXECUTED 21b64: eb005f1a bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 21b68: e5960000 ldr r0, [r6] <== NOT EXECUTED 21b6c: ebffaa9c bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 21b70: e1a00005 mov r0, r5 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
21b74: eaffffe4 b 21b0c <rtems_rfs_rtems_rename+0x84> <== NOT EXECUTED
000218ac <rtems_rfs_rtems_rmnod>:
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
218ac: e5912010 ldr r2, [r1, #16] <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
218b0: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
218b4: e5924034 ldr r4, [r2, #52] ; 0x34 <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
218b8: e1a03001 mov r3, r1 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
218bc: e594207c ldr r2, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc); rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc); rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc); uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (pathloc);
218c0: e5915004 ldr r5, [r1, #4] <== NOT EXECUTED
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_pathloc);
218c4: e5907000 ldr r7, [r0] <== NOT EXECUTED 218c8: e3a01000 mov r1, #0 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
218cc: e5936000 ldr r6, [r3] <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_rmnod (rtems_filesystem_location_info_t* parent_pathloc,
rtems_filesystem_location_info_t* pathloc)
{
218d0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 218d4: e5920000 ldr r0, [r2] <== NOT EXECUTED 218d8: e1a02001 mov r2, r1 <== NOT EXECUTED 218dc: ebffaaf8 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
printf ("rtems-rfs: rmnod: parent:%" PRId32 " doff:%" PRIu32 ", ino:%" PRId32 "\n",
parent, doff, ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
218e0: e1a03005 mov r3, r5 <== NOT EXECUTED 218e4: e3a0c000 mov ip, #0 <== NOT EXECUTED 218e8: e1a01007 mov r1, r7 <== NOT EXECUTED 218ec: e1a02006 mov r2, r6 <== NOT EXECUTED 218f0: e1a00004 mov r0, r4 <== NOT EXECUTED 218f4: e58dc000 str ip, [sp] <== NOT EXECUTED 218f8: eb007051 bl 3da44 <rtems_rfs_unlink> <== NOT EXECUTED
if (rc)
218fc: e2505000 subs r5, r0, #0 <== NOT EXECUTED 21900: 0a000009 beq 2192c <rtems_rfs_rtems_rmnod+0x80> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
21904: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21908: e1a00004 mov r0, r4 <== NOT EXECUTED 2190c: eb005fb0 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
21910: e5960000 ldr r0, [r6] <== NOT EXECUTED 21914: ebffab32 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("rmnod: unlinking", rc);
21918: eb0085b4 bl 42ff0 <__errno> <== NOT EXECUTED 2191c: e5805000 str r5, [r0] <== NOT EXECUTED 21920: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
21924: e28dd004 add sp, sp, #4 <== NOT EXECUTED
21928: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
2192c: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21930: e1a00004 mov r0, r4 <== NOT EXECUTED 21934: eb005fa6 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 21938: e5960000 ldr r0, [r6] <== NOT EXECUTED 2193c: ebffab28 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 21940: e1a00005 mov r0, r5 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("rmnod: unlinking", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
21944: eafffff6 b 21924 <rtems_rfs_rtems_rmnod+0x78> <== NOT EXECUTED
00022924 <rtems_rfs_rtems_set_handlers>:
*/
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
22924: e92d4010 push {r4, lr} <== NOT EXECUTED
22928: e591300c ldr r3, [r1, #12] <== NOT EXECUTED
2292c: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED
22930: e5d31002 ldrb r1, [r3, #2] <== NOT EXECUTED
22934: e1821401 orr r1, r2, r1, lsl #8 <== NOT EXECUTED
uint16_t mode = rtems_rfs_inode_get_mode (inode); loc->handlers = NULL; if (RTEMS_RFS_S_ISDIR (mode))
22938: e2013a0f and r3, r1, #61440 ; 0xf000 <== NOT EXECUTED
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
2293c: e3a02000 mov r2, #0 <== NOT EXECUTED
if (RTEMS_RFS_S_ISDIR (mode))
22940: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED
bool
rtems_rfs_rtems_set_handlers (rtems_filesystem_location_info_t* loc,
rtems_rfs_inode_handle* inode)
{
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
22944: e5802008 str r2, [r0, #8] <== NOT EXECUTED
if (RTEMS_RFS_S_ISDIR (mode))
22948: 0a000010 beq 22990 <rtems_rfs_rtems_set_handlers+0x6c> <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
2294c: e3530a02 cmp r3, #8192 ; 0x2000 <== NOT EXECUTED 22950: 13530a06 cmpne r3, #24576 ; 0x6000 <== NOT EXECUTED 22954: 13a04000 movne r4, #0 <== NOT EXECUTED 22958: 03a04001 moveq r4, #1 <== NOT EXECUTED 2295c: 0a000007 beq 22980 <rtems_rfs_rtems_set_handlers+0x5c> <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
22960: e3530a0a cmp r3, #40960 ; 0xa000 <== NOT EXECUTED 22964: 0a000011 beq 229b0 <rtems_rfs_rtems_set_handlers+0x8c> <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
22968: e3530902 cmp r3, #32768 ; 0x8000 <== NOT EXECUTED 2296c: 0a00000b beq 229a0 <rtems_rfs_rtems_set_handlers+0x7c> <== NOT EXECUTED
loc->handlers = rtems_rfs_rtems_handlers (file);
else
{
printf ("rtems-rfs: mode type unknown: %04x\n", mode);
22970: e59f0048 ldr r0, [pc, #72] ; 229c0 <rtems_rfs_rtems_set_handlers+0x9c><== NOT EXECUTED 22974: eb0092fb bl 47568 <printf> <== NOT EXECUTED 22978: e1a00004 mov r0, r4 <== NOT EXECUTED
return false;
}
return true;
}
2297c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
22980: e59f303c ldr r3, [pc, #60] ; 229c4 <rtems_rfs_rtems_set_handlers+0xa0><== NOT EXECUTED
22984: e5803008 str r3, [r0, #8] <== NOT EXECUTED
22988: e3a00001 mov r0, #1 <== NOT EXECUTED
2298c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
rtems_rfs_inode_handle* inode)
{
uint16_t mode = rtems_rfs_inode_get_mode (inode);
loc->handlers = NULL;
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
22990: e59f3030 ldr r3, [pc, #48] ; 229c8 <rtems_rfs_rtems_set_handlers+0xa4><== NOT EXECUTED
22994: e5803008 str r3, [r0, #8] <== NOT EXECUTED
22998: e3a00001 mov r0, #1 <== NOT EXECUTED
2299c: e8bd8010 pop {r4, pc} <== NOT EXECUTED
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
loc->handlers = rtems_rfs_rtems_handlers (link);
else if (RTEMS_RFS_S_ISREG (mode))
loc->handlers = rtems_rfs_rtems_handlers (file);
229a0: e59f3024 ldr r3, [pc, #36] ; 229cc <rtems_rfs_rtems_set_handlers+0xa8><== NOT EXECUTED
229a4: e5803008 str r3, [r0, #8] <== NOT EXECUTED
229a8: e3a00001 mov r0, #1 <== NOT EXECUTED
229ac: e8bd8010 pop {r4, pc} <== NOT EXECUTED
if (RTEMS_RFS_S_ISDIR (mode))
loc->handlers = rtems_rfs_rtems_handlers (dir);
else if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK(mode))
loc->handlers = rtems_rfs_rtems_handlers (device);
else if (RTEMS_RFS_S_ISLNK (mode))
loc->handlers = rtems_rfs_rtems_handlers (link);
229b0: e59f3018 ldr r3, [pc, #24] ; 229d0 <rtems_rfs_rtems_set_handlers+0xac><== NOT EXECUTED
229b4: e5803008 str r3, [r0, #8] <== NOT EXECUTED
229b8: e3a00001 mov r0, #1 <== NOT EXECUTED
229bc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00021130 <rtems_rfs_rtems_shutdown>:
* Shutdown the file system.
*/
int
rtems_rfs_rtems_shutdown (rtems_filesystem_mount_table_entry_t* mt_entry)
{
rtems_rfs_file_system* fs = mt_entry->fs_info;
21130: e5903034 ldr r3, [r0, #52] ; 0x34 <== NOT EXECUTED
/**
* Shutdown the file system.
*/
int
rtems_rfs_rtems_shutdown (rtems_filesystem_mount_table_entry_t* mt_entry)
{
21134: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
rtems_rfs_rtems_private* rtems;
int rc;
rtems = rtems_rfs_fs_user (fs);
rc = rtems_rfs_fs_close(fs);
21138: e1a00003 mov r0, r3 <== NOT EXECUTED
{
rtems_rfs_file_system* fs = mt_entry->fs_info;
rtems_rfs_rtems_private* rtems;
int rc;
rtems = rtems_rfs_fs_user (fs);
2113c: e593507c ldr r5, [r3, #124] ; 0x7c <== NOT EXECUTED
rc = rtems_rfs_fs_close(fs);
21140: eb006921 bl 3b5cc <rtems_rfs_fs_close> <== NOT EXECUTED 21144: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_rfs_mutex_destroy (&rtems->access);
21148: e1a00005 mov r0, r5 <== NOT EXECUTED 2114c: eb00731f bl 3ddd0 <rtems_rfs_mutex_destroy> <== NOT EXECUTED
free (rtems);
21150: e1a00005 mov r0, r5 <== NOT EXECUTED 21154: ebff9b05 bl 7d70 <free> <== NOT EXECUTED
return rtems_rfs_rtems_error ("shutdown: close", rc);
21158: eb0087a4 bl 42ff0 <__errno> <== NOT EXECUTED 2115c: e3540000 cmp r4, #0 <== NOT EXECUTED 21160: e5804000 str r4, [r0] <== NOT EXECUTED
}
21164: 01a00004 moveq r0, r4 <== NOT EXECUTED
21168: 13e00000 mvnne r0, #0 <== NOT EXECUTED
2116c: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00021ca4 <rtems_rfs_rtems_stat>:
int
rtems_rfs_rtems_stat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
21ca4: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
*/
int
rtems_rfs_rtems_stat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
21ca8: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
21cac: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
21cb0: e595307c ldr r3, [r5, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
21cb4: e5906000 ldr r6, [r0] <== NOT EXECUTED
*/
int
rtems_rfs_rtems_stat (rtems_filesystem_location_info_t* pathloc,
struct stat* buf)
{
21cb8: e1a04001 mov r4, r1 <== NOT EXECUTED 21cbc: e3a01000 mov r1, #0 <== NOT EXECUTED 21cc0: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 21cc4: e1a02001 mov r2, r1 <== NOT EXECUTED 21cc8: e5930000 ldr r0, [r3] <== NOT EXECUTED 21ccc: ebffa9fc bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
21cd0: e1a00005 mov r0, r5 <== NOT EXECUTED 21cd4: e1a01006 mov r1, r6 <== NOT EXECUTED 21cd8: e1a0200d mov r2, sp <== NOT EXECUTED 21cdc: e3a03001 mov r3, #1 <== NOT EXECUTED 21ce0: eb006d5f bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
21ce4: e2508000 subs r8, r0, #0 <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_STAT))
printf ("rtems-rfs-rtems: stat: in: ino:%" PRId32 "\n", ino);
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
21ce8: e1a0700d mov r7, sp <== NOT EXECUTED
if (rc)
21cec: 1a00006d bne 21ea8 <rtems_rfs_rtems_stat+0x204> <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
21cf0: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
return rtems_rfs_rtems_error ("stat: opening inode", rc);
}
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
21cf4: e5d23003 ldrb r3, [r2, #3] <== NOT EXECUTED 21cf8: e5d20002 ldrb r0, [r2, #2] <== NOT EXECUTED 21cfc: e1830400 orr r0, r3, r0, lsl #8 <== NOT EXECUTED 21d00: e2003a0f and r3, r0, #61440 ; 0xf000 <== NOT EXECUTED 21d04: e3530a02 cmp r3, #8192 ; 0x2000 <== NOT EXECUTED 21d08: 13530a06 cmpne r3, #24576 ; 0x6000 <== NOT EXECUTED 21d0c: 0a000040 beq 21e14 <rtems_rfs_rtems_stat+0x170> <== NOT EXECUTED
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
21d10: e595300c ldr r3, [r5, #12] <== NOT EXECUTED
21d14: e893000c ldm r3, {r2, r3} <== NOT EXECUTED
buf->st_ino = ino;
21d18: e5846008 str r6, [r4, #8] <== NOT EXECUTED
buf->st_rdev =
rtems_filesystem_make_dev_t (rtems_rfs_inode_get_block (&inode, 0),
rtems_rfs_inode_get_block (&inode, 1));
}
buf->st_dev = rtems_rfs_fs_device (fs);
21d1c: e884000c stm r4, {r2, r3} <== NOT EXECUTED
buf->st_ino = ino; buf->st_mode = rtems_rfs_rtems_mode (mode);
21d20: eb0002fe bl 22920 <rtems_rfs_rtems_mode> <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
21d24: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 21d28: e584000c str r0, [r4, #12] <== NOT EXECUTED 21d2c: e5d30000 ldrb r0, [r3] <== NOT EXECUTED 21d30: e5d32001 ldrb r2, [r3, #1] <== NOT EXECUTED
if (links == 0xffff)
21d34: e3a01801 mov r1, #65536 ; 0x10000 <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
21d38: e1822400 orr r2, r2, r0, lsl #8 <== NOT EXECUTED
if (links == 0xffff)
21d3c: e2411001 sub r1, r1, #1 <== NOT EXECUTED 21d40: e1520001 cmp r2, r1 <== NOT EXECUTED 21d44: 03a02000 moveq r2, #0 <== NOT EXECUTED
buf->st_nlink = rtems_rfs_inode_get_links (&inode);
21d48: e1c421b0 strh r2, [r4, #16] <== NOT EXECUTED
buf->st_uid = rtems_rfs_inode_get_uid (&inode);
21d4c: e5d31006 ldrb r1, [r3, #6] <== NOT EXECUTED 21d50: e5d32007 ldrb r2, [r3, #7] <== NOT EXECUTED 21d54: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED 21d58: e1c421b2 strh r2, [r4, #18] <== NOT EXECUTED
buf->st_gid = rtems_rfs_inode_get_gid (&inode);
21d5c: e5d31007 ldrb r1, [r3, #7] <== NOT EXECUTED 21d60: e5d30004 ldrb r0, [r3, #4] <== NOT EXECUTED 21d64: e5d32005 ldrb r2, [r3, #5] <== NOT EXECUTED 21d68: e1813c00 orr r3, r1, r0, lsl #24 <== NOT EXECUTED 21d6c: e1833802 orr r3, r3, r2, lsl #16 <== NOT EXECUTED 21d70: e1a03823 lsr r3, r3, #16 <== NOT EXECUTED 21d74: e1c431b4 strh r3, [r4, #20] <== NOT EXECUTED
/*
* Need to check is the ino is an open file. If so we take the values from
* the open file rather than the inode.
*/
shared = rtems_rfs_file_get_shared (fs, ino);
21d78: e1a01006 mov r1, r6 <== NOT EXECUTED 21d7c: e1a00005 mov r0, r5 <== NOT EXECUTED 21d80: eb006323 bl 3aa14 <rtems_rfs_file_get_shared> <== NOT EXECUTED
if (shared)
21d84: e3500000 cmp r0, #0 <== NOT EXECUTED 21d88: 0a00004f beq 21ecc <rtems_rfs_rtems_stat+0x228> <== NOT EXECUTED
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
21d8c: e590308c ldr r3, [r0, #140] ; 0x8c <== NOT EXECUTED 21d90: e5843028 str r3, [r4, #40] ; 0x28 <== NOT EXECUTED
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
21d94: e5903090 ldr r3, [r0, #144] ; 0x90 <== NOT EXECUTED 21d98: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
21d9c: e5903094 ldr r3, [r0, #148] ; 0x94 <== NOT EXECUTED
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
21da0: e594200c ldr r2, [r4, #12] <== NOT EXECUTED
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
21da4: e5843038 str r3, [r4, #56] ; 0x38 <== NOT EXECUTED
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
21da8: e2022a0f and r2, r2, #61440 ; 0xf000 <== NOT EXECUTED
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
21dac: e5903084 ldr r3, [r0, #132] ; 0x84 <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
21db0: e3520a0a cmp r2, #40960 ; 0xa000 <== NOT EXECUTED
if (shared)
{
buf->st_atime = rtems_rfs_file_shared_get_atime (shared);
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
21db4: e5843044 str r3, [r4, #68] ; 0x44 <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
21db8: 0a000028 beq 21e60 <rtems_rfs_rtems_stat+0x1bc> <== NOT EXECUTED
*/
static inline rtems_rfs_pos
rtems_rfs_file_shared_get_size (rtems_rfs_file_system* fs,
rtems_rfs_file_shared* shared)
{
return rtems_rfs_block_get_size (fs, &shared->size);
21dbc: e2801084 add r1, r0, #132 ; 0x84 <== NOT EXECUTED 21dc0: e1a00005 mov r0, r5 <== NOT EXECUTED 21dc4: eb005abc bl 388bc <rtems_rfs_block_get_size> <== NOT EXECUTED
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
21dc8: e5840020 str r0, [r4, #32] <== NOT EXECUTED 21dcc: e5841024 str r1, [r4, #36] ; 0x24 <== NOT EXECUTED
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
21dd0: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
21dd4: e1a0100d mov r1, sp <== NOT EXECUTED
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
21dd8: e5843040 str r3, [r4, #64] ; 0x40 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
21ddc: e1a00005 mov r0, r5 <== NOT EXECUTED 21de0: eb006cfb bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
21de4: e2504000 subs r4, r0, #0 <== NOT EXECUTED 21de8: da000027 ble 21e8c <rtems_rfs_rtems_stat+0x1e8> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
21dec: e595607c ldr r6, [r5, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21df0: e1a00005 mov r0, r5 <== NOT EXECUTED 21df4: eb005e76 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
21df8: e5960000 ldr r0, [r6] <== NOT EXECUTED 21dfc: ebffa9f8 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("stat: closing inode", rc);
21e00: eb00847a bl 42ff0 <__errno> <== NOT EXECUTED 21e04: e5804000 str r4, [r0] <== NOT EXECUTED 21e08: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
21e0c: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
21e10: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
21e14: e282301c add r3, r2, #28 <== NOT EXECUTED 21e18: e5d3a005 ldrb sl, [r3, #5] <== NOT EXECUTED
rtems_device_minor_number _minor
)
{
union __rtems_dev_t temp;
temp.__overlay.major = _major;
21e1c: e5d2101c ldrb r1, [r2, #28] <== NOT EXECUTED 21e20: e5d3c004 ldrb ip, [r3, #4] <== NOT EXECUTED 21e24: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED 21e28: e5d3e001 ldrb lr, [r3, #1] <== NOT EXECUTED 21e2c: e5d38007 ldrb r8, [r3, #7] <== NOT EXECUTED 21e30: e1a0a80a lsl sl, sl, #16 <== NOT EXECUTED 21e34: e18aac0c orr sl, sl, ip, lsl #24 <== NOT EXECUTED 21e38: e1822c01 orr r2, r2, r1, lsl #24 <== NOT EXECUTED 21e3c: e5d3c006 ldrb ip, [r3, #6] <== NOT EXECUTED 21e40: e5d31002 ldrb r1, [r3, #2] <== NOT EXECUTED 21e44: e182280e orr r2, r2, lr, lsl #16 <== NOT EXECUTED 21e48: e18a3008 orr r3, sl, r8 <== NOT EXECUTED 21e4c: e183340c orr r3, r3, ip, lsl #8 <== NOT EXECUTED 21e50: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED
mode = rtems_rfs_inode_get_mode (&inode);
if (RTEMS_RFS_S_ISCHR (mode) || RTEMS_RFS_S_ISBLK (mode))
{
buf->st_rdev =
21e54: e5842018 str r2, [r4, #24] <== NOT EXECUTED 21e58: e584301c str r3, [r4, #28] <== NOT EXECUTED 21e5c: eaffffab b 21d10 <rtems_rfs_rtems_stat+0x6c> <== NOT EXECUTED
buf->st_mtime = rtems_rfs_file_shared_get_mtime (shared);
buf->st_ctime = rtems_rfs_file_shared_get_ctime (shared);
buf->st_blocks = rtems_rfs_file_shared_get_block_count (shared);
if (S_ISLNK (buf->st_mode))
buf->st_size = rtems_rfs_file_shared_get_block_offset (shared);
21e60: e1d038b8 ldrh r3, [r0, #136] ; 0x88 <== NOT EXECUTED 21e64: e5843020 str r3, [r4, #32] <== NOT EXECUTED 21e68: e3a03000 mov r3, #0 <== NOT EXECUTED 21e6c: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
21e70: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
21e74: e1a0100d mov r1, sp <== NOT EXECUTED
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
}
buf->st_blksize = rtems_rfs_fs_block_size (fs);
21e78: e5843040 str r3, [r4, #64] ; 0x40 <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
21e7c: e1a00005 mov r0, r5 <== NOT EXECUTED 21e80: eb006cd3 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
21e84: e2504000 subs r4, r0, #0 <== NOT EXECUTED 21e88: caffffd7 bgt 21dec <rtems_rfs_rtems_stat+0x148> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
21e8c: e595407c ldr r4, [r5, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21e90: e1a00005 mov r0, r5 <== NOT EXECUTED 21e94: eb005e4e bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 21e98: e5940000 ldr r0, [r4] <== NOT EXECUTED 21e9c: ebffa9d0 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 21ea0: e3a00000 mov r0, #0 <== NOT EXECUTED
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("stat: closing inode", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
21ea4: eaffffd8 b 21e0c <rtems_rfs_rtems_stat+0x168> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
21ea8: e595407c ldr r4, [r5, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21eac: e1a00005 mov r0, r5 <== NOT EXECUTED 21eb0: eb005e47 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 21eb4: e5940000 ldr r0, [r4] <== NOT EXECUTED 21eb8: ebffa9c9 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc)
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("stat: opening inode", rc);
21ebc: eb00844b bl 42ff0 <__errno> <== NOT EXECUTED 21ec0: e5808000 str r8, [r0] <== NOT EXECUTED 21ec4: e3e00000 mvn r0, #0 <== NOT EXECUTED 21ec8: eaffffcf b 21e0c <rtems_rfs_rtems_stat+0x168> <== NOT EXECUTED
* @return rtems_rfs_time The atime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_atime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->atime);
21ecc: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 21ed0: e2832010 add r2, r3, #16 <== NOT EXECUTED
else
buf->st_size = rtems_rfs_file_shared_get_size (fs, shared);
}
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
21ed4: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED 21ed8: e5d3c010 ldrb ip, [r3, #16] <== NOT EXECUTED 21edc: e5d2e001 ldrb lr, [r2, #1] <== NOT EXECUTED 21ee0: e181cc0c orr ip, r1, ip, lsl #24 <== NOT EXECUTED 21ee4: e5d21002 ldrb r1, [r2, #2] <== NOT EXECUTED 21ee8: e18c280e orr r2, ip, lr, lsl #16 <== NOT EXECUTED 21eec: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED 21ef0: e5842028 str r2, [r4, #40] ; 0x28 <== NOT EXECUTED
* @return rtems_rfs_time The mtime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_mtime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->mtime);
21ef4: e2832014 add r2, r3, #20 <== NOT EXECUTED
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
21ef8: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED 21efc: e5d3c014 ldrb ip, [r3, #20] <== NOT EXECUTED 21f00: e5d2e001 ldrb lr, [r2, #1] <== NOT EXECUTED 21f04: e181cc0c orr ip, r1, ip, lsl #24 <== NOT EXECUTED 21f08: e5d21002 ldrb r1, [r2, #2] <== NOT EXECUTED 21f0c: e18c280e orr r2, ip, lr, lsl #16 <== NOT EXECUTED 21f10: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED 21f14: e5842030 str r2, [r4, #48] ; 0x30 <== NOT EXECUTED
* @return rtems_rfs_time The ctime.
*/
static inline rtems_rfs_time
rtems_rfs_inode_get_ctime (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->ctime);
21f18: e2832018 add r2, r3, #24 <== NOT EXECUTED
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
21f1c: e5d21003 ldrb r1, [r2, #3] <== NOT EXECUTED 21f20: e5d3c018 ldrb ip, [r3, #24] <== NOT EXECUTED 21f24: e5d2e001 ldrb lr, [r2, #1] <== NOT EXECUTED 21f28: e181cc0c orr ip, r1, ip, lsl #24 <== NOT EXECUTED 21f2c: e5d21002 ldrb r1, [r2, #2] <== NOT EXECUTED 21f30: e18c280e orr r2, ip, lr, lsl #16 <== NOT EXECUTED 21f34: e1822401 orr r2, r2, r1, lsl #8 <== NOT EXECUTED 21f38: e5842038 str r2, [r4, #56] ; 0x38 <== NOT EXECUTED
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
21f3c: e283200c add r2, r3, #12 <== NOT EXECUTED
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
21f40: e5d2c003 ldrb ip, [r2, #3] <== NOT EXECUTED 21f44: e5d3e00c ldrb lr, [r3, #12] <== NOT EXECUTED 21f48: e5d26001 ldrb r6, [r2, #1] <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
21f4c: e594100c ldr r1, [r4, #12] <== NOT EXECUTED
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
21f50: e18cec0e orr lr, ip, lr, lsl #24 <== NOT EXECUTED 21f54: e5d2c002 ldrb ip, [r2, #2] <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
21f58: e2011a0f and r1, r1, #61440 ; 0xf000 <== NOT EXECUTED
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
21f5c: e18e2806 orr r2, lr, r6, lsl #16 <== NOT EXECUTED 21f60: e182240c orr r2, r2, ip, lsl #8 <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
21f64: e3510a0a cmp r1, #40960 ; 0xa000 <== NOT EXECUTED
else
{
buf->st_atime = rtems_rfs_inode_get_atime (&inode);
buf->st_mtime = rtems_rfs_inode_get_mtime (&inode);
buf->st_ctime = rtems_rfs_inode_get_ctime (&inode);
buf->st_blocks = rtems_rfs_inode_get_block_count (&inode);
21f68: e5842044 str r2, [r4, #68] ; 0x44 <== NOT EXECUTED
if (S_ISLNK (buf->st_mode))
21f6c: 1a000005 bne 21f88 <rtems_rfs_rtems_stat+0x2e4> <== NOT EXECUTED
buf->st_size = rtems_rfs_inode_get_block_offset (&inode);
21f70: e5d3200b ldrb r2, [r3, #11] <== NOT EXECUTED 21f74: e5d3300a ldrb r3, [r3, #10] <== NOT EXECUTED 21f78: e1823403 orr r3, r2, r3, lsl #8 <== NOT EXECUTED 21f7c: e5843020 str r3, [r4, #32] <== NOT EXECUTED 21f80: e5840024 str r0, [r4, #36] ; 0x24 <== NOT EXECUTED 21f84: eaffff91 b 21dd0 <rtems_rfs_rtems_stat+0x12c> <== NOT EXECUTED
else
buf->st_size = rtems_rfs_inode_get_size (fs, &inode);
21f88: e1a00005 mov r0, r5 <== NOT EXECUTED 21f8c: e1a0100d mov r1, sp <== NOT EXECUTED 21f90: eb006bca bl 3cec0 <rtems_rfs_inode_get_size> <== NOT EXECUTED 21f94: e5840020 str r0, [r4, #32] <== NOT EXECUTED 21f98: e5841024 str r1, [r4, #36] ; 0x24 <== NOT EXECUTED 21f9c: eaffff8b b 21dd0 <rtems_rfs_rtems_stat+0x12c> <== NOT EXECUTED
00021348 <rtems_rfs_rtems_statvfs>:
* @return int
*/
int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
21348: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
2134c: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED 21350: e5935034 ldr r5, [r3, #52] ; 0x34 <== NOT EXECUTED
* @return int
*/
int
rtems_rfs_rtems_statvfs (rtems_filesystem_location_info_t* pathloc,
struct statvfs* sb)
{
21354: e24dd008 sub sp, sp, #8 <== NOT EXECUTED 21358: e1a04001 mov r4, r1 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
2135c: e1a0200d mov r2, sp <== NOT EXECUTED 21360: e28d1004 add r1, sp, #4 <== NOT EXECUTED 21364: e1a00005 mov r0, r5 <== NOT EXECUTED 21368: eb006d73 bl 3c93c <rtems_rfs_group_usage> <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs);
2136c: e5953008 ldr r3, [r5, #8] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
21370: e595000c ldr r0, [r5, #12] <== NOT EXECUTED
size_t blocks;
size_t inodes;
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
21374: e5843000 str r3, [r4] <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
21378: e5903024 ldr r3, [r0, #36] ; 0x24 <== NOT EXECUTED 2137c: e5843004 str r3, [r4, #4] <== NOT EXECUTED
sb->f_blocks = rtems_rfs_fs_media_blocks (fs); sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks; sb->f_bavail = sb->f_bfree; sb->f_files = rtems_rfs_fs_inodes (fs); sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
21380: e59d2000 ldr r2, [sp] <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs); sb->f_frsize = rtems_rfs_fs_media_block_size (fs); sb->f_blocks = rtems_rfs_fs_media_blocks (fs); sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks; sb->f_bavail = sb->f_bfree; sb->f_files = rtems_rfs_fs_inodes (fs);
21384: e5951010 ldr r1, [r5, #16] <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes; sb->f_favail = sb->f_ffree; sb->f_fsid = RTEMS_RFS_SB_MAGIC;
21388: e3a0334a mov r3, #671088641 ; 0x28000001 <== NOT EXECUTED
sb->f_frsize = rtems_rfs_fs_media_block_size (fs); sb->f_blocks = rtems_rfs_fs_media_blocks (fs); sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks; sb->f_bavail = sb->f_bfree; sb->f_files = rtems_rfs_fs_inodes (fs); sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
2138c: e0622001 rsb r2, r2, r1 <== NOT EXECUTED
sb->f_favail = sb->f_ffree; sb->f_fsid = RTEMS_RFS_SB_MAGIC;
21390: e2833a92 add r3, r3, #598016 ; 0x92000 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
21394: e590c01c ldr ip, [r0, #28] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
21398: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree; sb->f_files = rtems_rfs_fs_inodes (fs); sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes; sb->f_favail = sb->f_ffree;
2139c: e5842028 str r2, [r4, #40] ; 0x28 <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
213a0: e584302c str r3, [r4, #44] ; 0x2c <== NOT EXECUTED
sb->f_bsize = rtems_rfs_fs_block_size (fs); sb->f_frsize = rtems_rfs_fs_media_block_size (fs); sb->f_blocks = rtems_rfs_fs_media_blocks (fs); sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks; sb->f_bavail = sb->f_bfree; sb->f_files = rtems_rfs_fs_inodes (fs);
213a4: e5841020 str r1, [r4, #32] <== NOT EXECUTED
sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes;
213a8: e5842024 str r2, [r4, #36] ; 0x24 <== NOT EXECUTED
sb->f_favail = sb->f_ffree; sb->f_fsid = RTEMS_RFS_SB_MAGIC; sb->f_flag = rtems_rfs_fs_flags (fs);
213ac: e5953000 ldr r3, [r5] <== NOT EXECUTED 213b0: e5843030 str r3, [r4, #48] ; 0x30 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
213b4: e59d3004 ldr r3, [sp, #4] <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs); sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes; sb->f_favail = sb->f_ffree; sb->f_fsid = RTEMS_RFS_SB_MAGIC; sb->f_flag = rtems_rfs_fs_flags (fs); sb->f_namemax = rtems_rfs_fs_max_name (fs);
213b8: e5952018 ldr r2, [r5, #24] <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
213bc: e0633000 rsb r3, r3, r0 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
213c0: e3a00000 mov r0, #0 <== NOT EXECUTED
sb->f_files = rtems_rfs_fs_inodes (fs); sb->f_ffree = rtems_rfs_fs_inodes (fs) - inodes; sb->f_favail = sb->f_ffree; sb->f_fsid = RTEMS_RFS_SB_MAGIC; sb->f_flag = rtems_rfs_fs_flags (fs); sb->f_namemax = rtems_rfs_fs_max_name (fs);
213c4: e5842034 str r2, [r4, #52] ; 0x34 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
213c8: e584c008 str ip, [r4, #8] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks; sb->f_bavail = sb->f_bfree;
213cc: e5843018 str r3, [r4, #24] <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
sb->f_bsize = rtems_rfs_fs_block_size (fs);
sb->f_frsize = rtems_rfs_fs_media_block_size (fs);
sb->f_blocks = rtems_rfs_fs_media_blocks (fs);
213d0: e584000c str r0, [r4, #12] <== NOT EXECUTED
sb->f_bfree = rtems_rfs_fs_blocks (fs) - blocks;
213d4: e5843010 str r3, [r4, #16] <== NOT EXECUTED 213d8: e5840014 str r0, [r4, #20] <== NOT EXECUTED
sb->f_bavail = sb->f_bfree;
213dc: e584001c str r0, [r4, #28] <== NOT EXECUTED
sb->f_fsid = RTEMS_RFS_SB_MAGIC;
sb->f_flag = rtems_rfs_fs_flags (fs);
sb->f_namemax = rtems_rfs_fs_max_name (fs);
return 0;
}
213e0: e28dd008 add sp, sp, #8 <== NOT EXECUTED
213e4: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
000217f0 <rtems_rfs_rtems_symlink>:
int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
217f0: e1a03000 mov r3, r0 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
217f4: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
217f8: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
217fc: e5904034 ldr r4, [r0, #52] ; 0x34 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
21800: e594007c ldr r0, [r4, #124] ; 0x7c <== NOT EXECUTED
int
rtems_rfs_rtems_symlink (rtems_filesystem_location_info_t* parent_loc,
const char* link_name,
const char* node_name)
{
21804: e1a06001 mov r6, r1 <== NOT EXECUTED 21808: e3a01000 mov r1, #0 <== NOT EXECUTED 2180c: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 21810: e1a07002 mov r7, r2 <== NOT EXECUTED 21814: e5900000 ldr r0, [r0] <== NOT EXECUTED 21818: e1a02001 mov r2, r1 <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc); rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
2181c: e5935000 ldr r5, [r3] <== NOT EXECUTED 21820: ebffab27 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
21824: e1a00007 mov r0, r7 <== NOT EXECUTED 21828: eb00a0ed bl 49be4 <strlen> <== NOT EXECUTED 2182c: e1a08000 mov r8, r0 <== NOT EXECUTED
link_name, strlen (link_name),
21830: e1a00006 mov r0, r6 <== NOT EXECUTED 21834: eb00a0ea bl 49be4 <strlen> <== NOT EXECUTED
gid = 0;
#endif
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_symlink (fs, node_name, strlen (node_name),
21838: e3a0c000 mov ip, #0 <== NOT EXECUTED 2183c: e58d0000 str r0, [sp] <== NOT EXECUTED 21840: e1a01007 mov r1, r7 <== NOT EXECUTED 21844: e1a02008 mov r2, r8 <== NOT EXECUTED 21848: e1a03006 mov r3, r6 <== NOT EXECUTED 2184c: e1a00004 mov r0, r4 <== NOT EXECUTED 21850: e58d500c str r5, [sp, #12] <== NOT EXECUTED 21854: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 21858: e58dc004 str ip, [sp, #4] <== NOT EXECUTED 2185c: eb006fec bl 3d814 <rtems_rfs_symlink> <== NOT EXECUTED
link_name, strlen (link_name),
uid, gid, parent);
if (rc)
21860: e2505000 subs r5, r0, #0 <== NOT EXECUTED 21864: 0a000009 beq 21890 <rtems_rfs_rtems_symlink+0xa0> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
21868: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
2186c: e1a00004 mov r0, r4 <== NOT EXECUTED 21870: eb005fd7 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
21874: e5960000 ldr r0, [r6] <== NOT EXECUTED 21878: ebffab59 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("symlink: linking", rc);
2187c: eb0085db bl 42ff0 <__errno> <== NOT EXECUTED 21880: e5805000 str r5, [r0] <== NOT EXECUTED 21884: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
21888: e28dd010 add sp, sp, #16 <== NOT EXECUTED
2188c: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
21890: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21894: e1a00004 mov r0, r4 <== NOT EXECUTED 21898: eb005fcd bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 2189c: e5960000 ldr r0, [r6] <== NOT EXECUTED 218a0: ebffab4f bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 218a4: e1a00005 mov r0, r5 <== NOT EXECUTED
return rtems_rfs_rtems_error ("symlink: linking", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
218a8: eafffff6 b 21888 <rtems_rfs_rtems_symlink+0x98> <== NOT EXECUTED
00021948 <rtems_rfs_rtems_unlink>:
int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
21948: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
*/
int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
2194c: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
21950: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
*/
int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
21954: e1a03001 mov r3, r1 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
21958: e594207c ldr r2, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc); rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc); rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (loc); uint32_t doff = rtems_rfs_rtems_get_pathloc_doff (loc);
2195c: e5915004 ldr r5, [r1, #4] <== NOT EXECUTED
int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (parent_loc);
rtems_rfs_ino parent = rtems_rfs_rtems_get_pathloc_ino (parent_loc);
21960: e5907000 ldr r7, [r0] <== NOT EXECUTED 21964: e3a01000 mov r1, #0 <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (loc);
21968: e5936000 ldr r6, [r3] <== NOT EXECUTED
*/
int
rtems_rfs_rtems_unlink (rtems_filesystem_location_info_t* parent_loc,
rtems_filesystem_location_info_t* loc)
{
2196c: e24dd004 sub sp, sp, #4 <== NOT EXECUTED 21970: e5920000 ldr r0, [r2] <== NOT EXECUTED 21974: e1a02001 mov r2, r1 <== NOT EXECUTED 21978: ebffaad1 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
if (rtems_rfs_rtems_trace (RTEMS_RFS_RTEMS_DEBUG_UNLINK))
printf("rtems-rfs-rtems: unlink: parent:%" PRId32 " doff:%" PRIu32 " ino:%" PRId32 "\n",
parent, doff, ino);
rc = rtems_rfs_unlink (fs, parent, ino, doff, rtems_rfs_unlink_dir_denied);
2197c: e1a03005 mov r3, r5 <== NOT EXECUTED 21980: e3a0c000 mov ip, #0 <== NOT EXECUTED 21984: e1a01007 mov r1, r7 <== NOT EXECUTED 21988: e1a02006 mov r2, r6 <== NOT EXECUTED 2198c: e1a00004 mov r0, r4 <== NOT EXECUTED 21990: e58dc000 str ip, [sp] <== NOT EXECUTED 21994: eb00702a bl 3da44 <rtems_rfs_unlink> <== NOT EXECUTED
if (rc)
21998: e2505000 subs r5, r0, #0 <== NOT EXECUTED 2199c: 0a000009 beq 219c8 <rtems_rfs_rtems_unlink+0x80> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
219a0: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
219a4: e1a00004 mov r0, r4 <== NOT EXECUTED 219a8: eb005f89 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
219ac: e5960000 ldr r0, [r6] <== NOT EXECUTED 219b0: ebffab0b bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("unlink: unlink inode", rc);
219b4: eb00858d bl 42ff0 <__errno> <== NOT EXECUTED 219b8: e5805000 str r5, [r0] <== NOT EXECUTED 219bc: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
219c0: e28dd004 add sp, sp, #4 <== NOT EXECUTED
219c4: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
219c8: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
219cc: e1a00004 mov r0, r4 <== NOT EXECUTED 219d0: eb005f7f bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 219d4: e5960000 ldr r0, [r6] <== NOT EXECUTED 219d8: ebffab01 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 219dc: e1a00005 mov r0, r5 <== NOT EXECUTED
return rtems_rfs_rtems_error ("unlink: unlink inode", rc);
}
rtems_rfs_rtems_unlock (fs);
return 0;
219e0: eafffff6 b 219c0 <rtems_rfs_rtems_unlink+0x78> <== NOT EXECUTED
00021118 <rtems_rfs_rtems_unlock>:
/**
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
21118: e92d4010 push {r4, lr} <== NOT EXECUTED
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
2111c: e590407c ldr r4, [r0, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21120: eb0061ab bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
21124: e5940000 ldr r0, [r4] <== NOT EXECUTED
rtems_rfs_mutex_unlock (&rtems->access); }
21128: e8bd4010 pop {r4, lr} <== NOT EXECUTED
2112c: eaffad2c b c5e4 <rtems_semaphore_release> <== NOT EXECUTED
00021b78 <rtems_rfs_rtems_utime>:
int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
21b78: e5903010 ldr r3, [r0, #16] <== NOT EXECUTED
int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
21b7c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
rtems_rfs_file_system* fs = rtems_rfs_rtems_pathloc_dev (pathloc);
21b80: e5934034 ldr r4, [r3, #52] ; 0x34 <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
21b84: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_ino ino = rtems_rfs_rtems_get_pathloc_ino (pathloc);
21b88: e5908000 ldr r8, [r0] <== NOT EXECUTED
int
rtems_rfs_rtems_utime(rtems_filesystem_location_info_t* pathloc,
time_t atime,
time_t mtime)
{
21b8c: e1a06001 mov r6, r1 <== NOT EXECUTED 21b90: e3a01000 mov r1, #0 <== NOT EXECUTED 21b94: e24dd028 sub sp, sp, #40 ; 0x28 <== NOT EXECUTED 21b98: e5930000 ldr r0, [r3] <== NOT EXECUTED 21b9c: e1a05002 mov r5, r2 <== NOT EXECUTED 21ba0: e1a02001 mov r2, r1 <== NOT EXECUTED 21ba4: ebffaa46 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
21ba8: e1a01008 mov r1, r8 <== NOT EXECUTED 21bac: e1a00004 mov r0, r4 <== NOT EXECUTED 21bb0: e1a0200d mov r2, sp <== NOT EXECUTED 21bb4: e3a03001 mov r3, #1 <== NOT EXECUTED 21bb8: eb006da9 bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
21bbc: e2508000 subs r8, r0, #0 <== NOT EXECUTED
rtems_rfs_inode_handle inode;
int rc;
rtems_rfs_rtems_lock (fs);
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
21bc0: e1a0700d mov r7, sp <== NOT EXECUTED
if (rc)
21bc4: 0a000009 beq 21bf0 <rtems_rfs_rtems_utime+0x78> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
21bc8: e594507c ldr r5, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21bcc: e1a00004 mov r0, r4 <== NOT EXECUTED 21bd0: eb005eff bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_unlock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_release (*mutex);
21bd4: e5950000 ldr r0, [r5] <== NOT EXECUTED 21bd8: ebffaa81 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("utime: read inode", rc);
21bdc: eb008503 bl 42ff0 <__errno> <== NOT EXECUTED 21be0: e5808000 str r8, [r0] <== NOT EXECUTED 21be4: e3e00000 mvn r0, #0 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
}
21be8: e28dd028 add sp, sp, #40 ; 0x28 <== NOT EXECUTED
21bec: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_atime (rtems_rfs_inode_handle* handle,
rtems_rfs_time atime)
{
rtems_rfs_write_u32 (&handle->node->atime, atime);
21bf0: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 21bf4: e1a02c26 lsr r2, r6, #24 <== NOT EXECUTED 21bf8: e5c32010 strb r2, [r3, #16] <== NOT EXECUTED 21bfc: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 21c00: e1a02826 lsr r2, r6, #16 <== NOT EXECUTED 21c04: e5c32011 strb r2, [r3, #17] <== NOT EXECUTED 21c08: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 21c0c: e1a02426 lsr r2, r6, #8 <== NOT EXECUTED 21c10: e5c32012 strb r2, [r3, #18] <== NOT EXECUTED 21c14: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 21c18: e5c36013 strb r6, [r3, #19] <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_mtime (rtems_rfs_inode_handle* handle,
rtems_rfs_time mtime)
{
rtems_rfs_write_u32 (&handle->node->mtime, mtime);
21c1c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 21c20: e1a02c25 lsr r2, r5, #24 <== NOT EXECUTED 21c24: e5c32014 strb r2, [r3, #20] <== NOT EXECUTED 21c28: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 21c2c: e1a02825 lsr r2, r5, #16 <== NOT EXECUTED 21c30: e5c32015 strb r2, [r3, #21] <== NOT EXECUTED 21c34: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 21c38: e1a02425 lsr r2, r5, #8 <== NOT EXECUTED 21c3c: e5c32016 strb r2, [r3, #22] <== NOT EXECUTED 21c40: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
}
rtems_rfs_inode_set_atime (&inode, atime);
rtems_rfs_inode_set_mtime (&inode, mtime);
rc = rtems_rfs_inode_close (fs, &inode);
21c44: e1a0100d mov r1, sp <== NOT EXECUTED 21c48: e5c35017 strb r5, [r3, #23] <== NOT EXECUTED 21c4c: e1a00004 mov r0, r4 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
21c50: e3a03001 mov r3, #1 <== NOT EXECUTED 21c54: e5cd3010 strb r3, [sp, #16] <== NOT EXECUTED 21c58: eb006d5d bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc)
21c5c: e2505000 subs r5, r0, #0 <== NOT EXECUTED 21c60: 0a000008 beq 21c88 <rtems_rfs_rtems_utime+0x110> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
21c64: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21c68: e1a00004 mov r0, r4 <== NOT EXECUTED 21c6c: eb005ed8 bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 21c70: e5960000 ldr r0, [r6] <== NOT EXECUTED 21c74: ebffaa5a bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED
{
rtems_rfs_rtems_unlock (fs);
return rtems_rfs_rtems_error ("utime: closing inode", rc);
21c78: eb0084dc bl 42ff0 <__errno> <== NOT EXECUTED 21c7c: e5805000 str r5, [r0] <== NOT EXECUTED 21c80: e3e00000 mvn r0, #0 <== NOT EXECUTED 21c84: eaffffd7 b 21be8 <rtems_rfs_rtems_utime+0x70> <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
21c88: e594607c ldr r6, [r4, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
21c8c: e1a00004 mov r0, r4 <== NOT EXECUTED 21c90: eb005ecf bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 21c94: e5960000 ldr r0, [r6] <== NOT EXECUTED 21c98: ebffaa51 bl c5e4 <rtems_semaphore_release> <== NOT EXECUTED 21c9c: e1a00005 mov r0, r5 <== NOT EXECUTED
}
rtems_rfs_rtems_unlock (fs);
return 0;
21ca0: eaffffd0 b 21be8 <rtems_rfs_rtems_utime+0x70> <== NOT EXECUTED
0003bb3c <rtems_rfs_rup_quotient>:
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
if (dividend == 0)
3bb3c: e3500000 cmp r0, #0 <== NOT EXECUTED
* Return a rounded up integer quotient given a dividend and divisor. That is:
* "quotient = dividend / divisor"
*/
int
rtems_rfs_rup_quotient (uint32_t dividend, uint32_t divisor)
{
3bb40: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
if (dividend == 0)
3bb44: 03a00001 moveq r0, #1 <== NOT EXECUTED
3bb48: 049df004 popeq {pc} ; (ldreq pc, [sp], #4) <== NOT EXECUTED
return 1;
return ((dividend - 1) / divisor) + 1;
3bb4c: e2400001 sub r0, r0, #1 <== NOT EXECUTED 3bb50: eb007ce4 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 3bb54: e2800001 add r0, r0, #1 <== NOT EXECUTED
}
3bb58: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
0002367c <rtems_rfs_shell_block>:
return 0;
}
static int
rtems_rfs_shell_block (rtems_rfs_file_system* fs, int argc, char *argv[])
{
2367c: e92d41f0 push {r4, r5, r6, r7, r8, lr} <== NOT EXECUTED
uint8_t* data;
bool state;
int b;
int rc;
if (argc <= 1)
23680: e3510001 cmp r1, #1 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_block (rtems_rfs_file_system* fs, int argc, char *argv[])
{
23684: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 23688: e1a04000 mov r4, r0 <== NOT EXECUTED
uint8_t* data;
bool state;
int b;
int rc;
if (argc <= 1)
2368c: da000070 ble 23854 <rtems_rfs_shell_block+0x1d8> <== NOT EXECUTED
{
printf ("error: no block number provided\n");
return 1;
}
block = strtoul (argv[1], 0, 0);
23690: e3a01000 mov r1, #0 <== NOT EXECUTED 23694: e5920004 ldr r0, [r2, #4] <== NOT EXECUTED 23698: e1a02001 mov r2, r1 <== NOT EXECUTED 2369c: eb009e6c bl 4b054 <strtoul> <== NOT EXECUTED 236a0: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED 236a4: e3a01000 mov r1, #0 <== NOT EXECUTED 236a8: e1a02001 mov r2, r1 <== NOT EXECUTED 236ac: e1a05000 mov r5, r0 <== NOT EXECUTED 236b0: e5930000 ldr r0, [r3] <== NOT EXECUTED 236b4: ebffa382 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_rfs_shell_lock_rfs (fs);
rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
236b8: e1a00004 mov r0, r4 <== NOT EXECUTED 236bc: e3a01000 mov r1, #0 <== NOT EXECUTED 236c0: e1a02005 mov r2, r5 <== NOT EXECUTED 236c4: e28d300f add r3, sp, #15 <== NOT EXECUTED 236c8: eb0064c0 bl 3c9d0 <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
if (rc > 0)
236cc: e2506000 subs r6, r0, #0 <== NOT EXECUTED 236d0: ca00003f bgt 237d4 <rtems_rfs_shell_block+0x158> <== NOT EXECUTED
printf ("error: testing block state: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
236d4: e5dd100f ldrb r1, [sp, #15] <== NOT EXECUTED 236d8: e59f3184 ldr r3, [pc, #388] ; 23864 <rtems_rfs_shell_block+0x1e8><== NOT EXECUTED 236dc: e3510000 cmp r1, #0 <== NOT EXECUTED 236e0: e59f2180 ldr r2, [pc, #384] ; 23868 <rtems_rfs_shell_block+0x1ec><== NOT EXECUTED 236e4: e1a01005 mov r1, r5 <== NOT EXECUTED 236e8: 01a02003 moveq r2, r3 <== NOT EXECUTED 236ec: e59f0178 ldr r0, [pc, #376] ; 2386c <rtems_rfs_shell_block+0x1f0><== NOT EXECUTED 236f0: eb008f9c bl 47568 <printf> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
236f4: e3a06000 mov r6, #0 <== NOT EXECUTED
printf ("error: opening buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
236f8: e1a00004 mov r0, r4 <== NOT EXECUTED 236fc: e1a0100d mov r1, sp <== NOT EXECUTED 23700: e1a02005 mov r2, r5 <== NOT EXECUTED 23704: e3a03001 mov r3, #1 <== NOT EXECUTED 23708: e5cd6000 strb r6, [sp] <== NOT EXECUTED
handle->bnum = 0;
2370c: e58d6004 str r6, [sp, #4] <== NOT EXECUTED
handle->buffer = NULL;
23710: e58d6008 str r6, [sp, #8] <== NOT EXECUTED 23714: eb0058ce bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
23718: e2508000 subs r8, r0, #0 <== NOT EXECUTED
printf ("error: opening buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
2371c: e1a0700d mov r7, sp <== NOT EXECUTED
if (rc > 0)
23720: ca00003a bgt 23810 <rtems_rfs_shell_block+0x194> <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
}
for (b = 0, data = rtems_rfs_buffer_data (&buffer);
b < rtems_rfs_fs_block_size (fs);
23724: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED 23728: e3530000 cmp r3, #0 <== NOT EXECUTED
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
for (b = 0, data = rtems_rfs_buffer_data (&buffer);
2372c: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 23730: e5935020 ldr r5, [r3, #32] <== NOT EXECUTED
b < rtems_rfs_fs_block_size (fs);
23734: 1a00000c bne 2376c <rtems_rfs_shell_block+0xf0> <== NOT EXECUTED 23738: ea000018 b 237a0 <rtems_rfs_shell_block+0x124> <== NOT EXECUTED
b++, data++)
{
int mod = b % 16;
if (mod == 0)
{
if (b)
2373c: e3560000 cmp r6, #0 <== NOT EXECUTED 23740: 1a00002f bne 23804 <rtems_rfs_shell_block+0x188> <== NOT EXECUTED
printf ("\n");
printf ("%04x ", b);
23744: e1a01006 mov r1, r6 <== NOT EXECUTED 23748: e59f0120 ldr r0, [pc, #288] ; 23870 <rtems_rfs_shell_block+0x1f4><== NOT EXECUTED 2374c: eb008f85 bl 47568 <printf> <== NOT EXECUTED
}
if (mod == 8)
printf (" ");
printf ("%02x ", *data);
23750: e7d51006 ldrb r1, [r5, r6] <== NOT EXECUTED 23754: e59f0118 ldr r0, [pc, #280] ; 23874 <rtems_rfs_shell_block+0x1f8><== NOT EXECUTED 23758: eb008f82 bl 47568 <printf> <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
}
for (b = 0, data = rtems_rfs_buffer_data (&buffer);
b < rtems_rfs_fs_block_size (fs);
2375c: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
b++, data++)
23760: e2866001 add r6, r6, #1 <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
}
for (b = 0, data = rtems_rfs_buffer_data (&buffer);
b < rtems_rfs_fs_block_size (fs);
23764: e1530006 cmp r3, r6 <== NOT EXECUTED 23768: 9a00000c bls 237a0 <rtems_rfs_shell_block+0x124> <== NOT EXECUTED
b++, data++)
{
int mod = b % 16;
if (mod == 0)
2376c: e216300f ands r3, r6, #15 <== NOT EXECUTED 23770: 0afffff1 beq 2373c <rtems_rfs_shell_block+0xc0> <== NOT EXECUTED
{
if (b)
printf ("\n");
printf ("%04x ", b);
}
if (mod == 8)
23774: e3530008 cmp r3, #8 <== NOT EXECUTED 23778: 1afffff4 bne 23750 <rtems_rfs_shell_block+0xd4> <== NOT EXECUTED
printf (" ");
2377c: e3a00020 mov r0, #32 <== NOT EXECUTED 23780: eb008fed bl 4773c <putchar> <== NOT EXECUTED
printf ("%02x ", *data);
23784: e7d51006 ldrb r1, [r5, r6] <== NOT EXECUTED 23788: e59f00e4 ldr r0, [pc, #228] ; 23874 <rtems_rfs_shell_block+0x1f8><== NOT EXECUTED 2378c: eb008f75 bl 47568 <printf> <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
}
for (b = 0, data = rtems_rfs_buffer_data (&buffer);
b < rtems_rfs_fs_block_size (fs);
23790: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
b++, data++)
23794: e2866001 add r6, r6, #1 <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
}
for (b = 0, data = rtems_rfs_buffer_data (&buffer);
b < rtems_rfs_fs_block_size (fs);
23798: e1530006 cmp r3, r6 <== NOT EXECUTED 2379c: 8afffff2 bhi 2376c <rtems_rfs_shell_block+0xf0> <== NOT EXECUTED
if (mod == 8)
printf (" ");
printf ("%02x ", *data);
}
printf ("\n");
237a0: e3a0000a mov r0, #10 <== NOT EXECUTED 237a4: eb008fe4 bl 4773c <putchar> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
237a8: e1a00004 mov r0, r4 <== NOT EXECUTED 237ac: e1a0100d mov r1, sp <== NOT EXECUTED 237b0: eb00585d bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
printf ("error: closing buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
rtems_rfs_shell_unlock_rfs (fs);
237b4: e1a00004 mov r0, r4 <== NOT EXECUTED
handle->dirty = false;
237b8: e3a04000 mov r4, #0 <== NOT EXECUTED 237bc: e5cd4000 strb r4, [sp] <== NOT EXECUTED
handle->bnum = 0;
237c0: e58d4004 str r4, [sp, #4] <== NOT EXECUTED
handle->buffer = NULL;
237c4: e58d4008 str r4, [sp, #8] <== NOT EXECUTED 237c8: ebfffd52 bl 22d18 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED 237cc: e1a00004 mov r0, r4 <== NOT EXECUTED
return 0;
237d0: ea000009 b 237fc <rtems_rfs_shell_block+0x180> <== NOT EXECUTED
rtems_rfs_shell_lock_rfs (fs);
rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
if (rc > 0)
{
rtems_rfs_shell_unlock_rfs (fs);
237d4: e1a00004 mov r0, r4 <== NOT EXECUTED 237d8: ebfffd4e bl 22d18 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
printf ("error: testing block state: block=%" PRIu32 ": (%d) %s\n",
237dc: e1a00006 mov r0, r6 <== NOT EXECUTED 237e0: eb009773 bl 495b4 <strerror> <== NOT EXECUTED 237e4: e1a01005 mov r1, r5 <== NOT EXECUTED 237e8: e1a03000 mov r3, r0 <== NOT EXECUTED 237ec: e1a02006 mov r2, r6 <== NOT EXECUTED 237f0: e59f0080 ldr r0, [pc, #128] ; 23878 <rtems_rfs_shell_block+0x1fc><== NOT EXECUTED 237f4: eb008f5b bl 47568 <printf> <== NOT EXECUTED 237f8: e3a00001 mov r0, #1 <== NOT EXECUTED
}
rtems_rfs_shell_unlock_rfs (fs);
return 0;
}
237fc: e28dd010 add sp, sp, #16 <== NOT EXECUTED
23800: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
{
int mod = b % 16;
if (mod == 0)
{
if (b)
printf ("\n");
23804: e3a0000a mov r0, #10 <== NOT EXECUTED 23808: eb008fcb bl 4773c <putchar> <== NOT EXECUTED 2380c: eaffffcc b 23744 <rtems_rfs_shell_block+0xc8> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
23810: e1a0100d mov r1, sp <== NOT EXECUTED 23814: e1a00004 mov r0, r4 <== NOT EXECUTED 23818: eb005843 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_shell_unlock_rfs (fs);
2381c: e1a00004 mov r0, r4 <== NOT EXECUTED
handle->dirty = false; handle->bnum = 0; handle->buffer = NULL;
23820: e58d6008 str r6, [sp, #8] <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
23824: e5cd6000 strb r6, [sp] <== NOT EXECUTED
handle->bnum = 0;
23828: e58d6004 str r6, [sp, #4] <== NOT EXECUTED 2382c: ebfffd39 bl 22d18 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
23830: e1a00008 mov r0, r8 <== NOT EXECUTED 23834: eb00975e bl 495b4 <strerror> <== NOT EXECUTED 23838: e1a01005 mov r1, r5 <== NOT EXECUTED 2383c: e1a03000 mov r3, r0 <== NOT EXECUTED 23840: e1a02008 mov r2, r8 <== NOT EXECUTED 23844: e59f0030 ldr r0, [pc, #48] ; 2387c <rtems_rfs_shell_block+0x200><== NOT EXECUTED 23848: eb008f46 bl 47568 <printf> <== NOT EXECUTED 2384c: e3a00001 mov r0, #1 <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
23850: eaffffe9 b 237fc <rtems_rfs_shell_block+0x180> <== NOT EXECUTED
int b;
int rc;
if (argc <= 1)
{
printf ("error: no block number provided\n");
23854: e59f0024 ldr r0, [pc, #36] ; 23880 <rtems_rfs_shell_block+0x204><== NOT EXECUTED 23858: eb008fe7 bl 477fc <puts> <== NOT EXECUTED 2385c: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
23860: eaffffe5 b 237fc <rtems_rfs_shell_block+0x180> <== NOT EXECUTED
00023884 <rtems_rfs_shell_data>:
return rc;
}
static int
rtems_rfs_shell_data (rtems_rfs_file_system* fs, int argc, char *argv[])
{
23884: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
23888: e1a04000 mov r4, r0 <== NOT EXECUTED
2388c: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
size_t blocks;
size_t inodes;
int bpcent;
int ipcent;
printf ("RFS Filesystem Data\n");
23890: e59f01a4 ldr r0, [pc, #420] ; 23a3c <rtems_rfs_shell_data+0x1b8><== NOT EXECUTED 23894: eb008fd8 bl 477fc <puts> <== NOT EXECUTED
printf (" flags: %08" PRIx32 "\n", fs->flags);
23898: e5941000 ldr r1, [r4] <== NOT EXECUTED 2389c: e59f019c ldr r0, [pc, #412] ; 23a40 <rtems_rfs_shell_data+0x1bc><== NOT EXECUTED 238a0: eb008f30 bl 47568 <printf> <== NOT EXECUTED
#if 0
printf (" device: %08lx\n", rtems_rfs_fs_device (fs));
#endif
printf (" blocks: %zu\n", rtems_rfs_fs_blocks (fs));
238a4: e5941004 ldr r1, [r4, #4] <== NOT EXECUTED 238a8: e59f0194 ldr r0, [pc, #404] ; 23a44 <rtems_rfs_shell_data+0x1c0><== NOT EXECUTED 238ac: eb008f2d bl 47568 <printf> <== NOT EXECUTED
printf (" block size: %zu\n", rtems_rfs_fs_block_size (fs));
238b0: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED 238b4: e59f018c ldr r0, [pc, #396] ; 23a48 <rtems_rfs_shell_data+0x1c4><== NOT EXECUTED 238b8: eb008f2a bl 47568 <printf> <== NOT EXECUTED
printf (" size: %" PRIu64 "\n", rtems_rfs_fs_size (fs));
238bc: e1a00004 mov r0, r4 <== NOT EXECUTED 238c0: eb005f30 bl 3b588 <rtems_rfs_fs_size> <== NOT EXECUTED 238c4: e1a02001 mov r2, r1 <== NOT EXECUTED 238c8: e1a01000 mov r1, r0 <== NOT EXECUTED 238cc: e59f0178 ldr r0, [pc, #376] ; 23a4c <rtems_rfs_shell_data+0x1c8><== NOT EXECUTED 238d0: eb008f24 bl 47568 <printf> <== NOT EXECUTED
printf (" media block size: %" PRIu32 "\n", rtems_rfs_fs_media_block_size (fs));
238d4: e594300c ldr r3, [r4, #12] <== NOT EXECUTED 238d8: e59f0170 ldr r0, [pc, #368] ; 23a50 <rtems_rfs_shell_data+0x1cc><== NOT EXECUTED 238dc: e5931024 ldr r1, [r3, #36] ; 0x24 <== NOT EXECUTED 238e0: eb008f20 bl 47568 <printf> <== NOT EXECUTED
printf (" media size: %" PRIu64 "\n", rtems_rfs_fs_media_size (fs));
238e4: e1a00004 mov r0, r4 <== NOT EXECUTED 238e8: eb005f2e bl 3b5a8 <rtems_rfs_fs_media_size> <== NOT EXECUTED 238ec: e1a02001 mov r2, r1 <== NOT EXECUTED 238f0: e1a01000 mov r1, r0 <== NOT EXECUTED 238f4: e59f0158 ldr r0, [pc, #344] ; 23a54 <rtems_rfs_shell_data+0x1d0><== NOT EXECUTED 238f8: eb008f1a bl 47568 <printf> <== NOT EXECUTED
printf (" inodes: %" PRIu32 "\n", rtems_rfs_fs_inodes (fs));
238fc: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED 23900: e59f0150 ldr r0, [pc, #336] ; 23a58 <rtems_rfs_shell_data+0x1d4><== NOT EXECUTED 23904: eb008f17 bl 47568 <printf> <== NOT EXECUTED
printf (" bad blocks: %" PRIu32 "\n", fs->bad_blocks);
23908: e5941014 ldr r1, [r4, #20] <== NOT EXECUTED 2390c: e59f0148 ldr r0, [pc, #328] ; 23a5c <rtems_rfs_shell_data+0x1d8><== NOT EXECUTED 23910: eb008f14 bl 47568 <printf> <== NOT EXECUTED
printf (" max. name length: %" PRIu32 "\n", rtems_rfs_fs_max_name (fs));
23914: e5941018 ldr r1, [r4, #24] <== NOT EXECUTED 23918: e59f0140 ldr r0, [pc, #320] ; 23a60 <rtems_rfs_shell_data+0x1dc><== NOT EXECUTED 2391c: eb008f11 bl 47568 <printf> <== NOT EXECUTED
printf (" groups: %d\n", fs->group_count);
23920: e5941020 ldr r1, [r4, #32] <== NOT EXECUTED 23924: e59f0138 ldr r0, [pc, #312] ; 23a64 <rtems_rfs_shell_data+0x1e0><== NOT EXECUTED 23928: eb008f0e bl 47568 <printf> <== NOT EXECUTED
printf (" group blocks: %zd\n", fs->group_blocks);
2392c: e5941024 ldr r1, [r4, #36] ; 0x24 <== NOT EXECUTED 23930: e59f0130 ldr r0, [pc, #304] ; 23a68 <rtems_rfs_shell_data+0x1e4><== NOT EXECUTED 23934: eb008f0b bl 47568 <printf> <== NOT EXECUTED
printf (" group inodes: %zd\n", fs->group_inodes);
23938: e5941028 ldr r1, [r4, #40] ; 0x28 <== NOT EXECUTED 2393c: e59f0128 ldr r0, [pc, #296] ; 23a6c <rtems_rfs_shell_data+0x1e8><== NOT EXECUTED 23940: eb008f08 bl 47568 <printf> <== NOT EXECUTED
printf (" inodes per block: %zd\n", fs->inodes_per_block);
23944: e594102c ldr r1, [r4, #44] ; 0x2c <== NOT EXECUTED 23948: e59f0120 ldr r0, [pc, #288] ; 23a70 <rtems_rfs_shell_data+0x1ec><== NOT EXECUTED 2394c: eb008f05 bl 47568 <printf> <== NOT EXECUTED
printf (" blocks per block: %zd\n", fs->blocks_per_block);
23950: e5941030 ldr r1, [r4, #48] ; 0x30 <== NOT EXECUTED 23954: e59f0118 ldr r0, [pc, #280] ; 23a74 <rtems_rfs_shell_data+0x1f0><== NOT EXECUTED 23958: eb008f02 bl 47568 <printf> <== NOT EXECUTED
printf (" singly blocks: %zd\n", fs->block_map_singly_blocks);
2395c: e5941034 ldr r1, [r4, #52] ; 0x34 <== NOT EXECUTED 23960: e59f0110 ldr r0, [pc, #272] ; 23a78 <rtems_rfs_shell_data+0x1f4><== NOT EXECUTED 23964: eb008eff bl 47568 <printf> <== NOT EXECUTED
printf (" doublly blocks: %zd\n", fs->block_map_doubly_blocks);
23968: e5941038 ldr r1, [r4, #56] ; 0x38 <== NOT EXECUTED 2396c: e59f0108 ldr r0, [pc, #264] ; 23a7c <rtems_rfs_shell_data+0x1f8><== NOT EXECUTED 23970: eb008efc bl 47568 <printf> <== NOT EXECUTED
printf (" max. held buffers: %" PRId32 "\n", fs->max_held_buffers);
23974: e594103c ldr r1, [r4, #60] ; 0x3c <== NOT EXECUTED 23978: e59f0100 ldr r0, [pc, #256] ; 23a80 <rtems_rfs_shell_data+0x1fc><== NOT EXECUTED 2397c: eb008ef9 bl 47568 <printf> <== NOT EXECUTED 23980: e594307c ldr r3, [r4, #124] ; 0x7c <== NOT EXECUTED 23984: e3a01000 mov r1, #0 <== NOT EXECUTED 23988: e5930000 ldr r0, [r3] <== NOT EXECUTED 2398c: e1a02001 mov r2, r1 <== NOT EXECUTED 23990: ebffa2cb bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_rfs_shell_lock_rfs (fs);
rtems_rfs_group_usage (fs, &blocks, &inodes);
23994: e1a0200d mov r2, sp <== NOT EXECUTED 23998: e28d1004 add r1, sp, #4 <== NOT EXECUTED 2399c: e1a00004 mov r0, r4 <== NOT EXECUTED 239a0: eb0063e5 bl 3c93c <rtems_rfs_group_usage> <== NOT EXECUTED
rtems_rfs_shell_unlock_rfs (fs);
239a4: e1a00004 mov r0, r4 <== NOT EXECUTED 239a8: ebfffcda bl 22d18 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
bpcent = (blocks * 1000) / rtems_rfs_fs_blocks (fs);
239ac: e59d6004 ldr r6, [sp, #4] <== NOT EXECUTED 239b0: e0860106 add r0, r6, r6, lsl #2 <== NOT EXECUTED 239b4: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 239b8: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 239bc: e5941004 ldr r1, [r4, #4] <== NOT EXECUTED 239c0: e1a00180 lsl r0, r0, #3 <== NOT EXECUTED 239c4: eb00dd47 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 239c8: e1a07000 mov r7, r0 <== NOT EXECUTED
ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);
239cc: e59d0000 ldr r0, [sp] <== NOT EXECUTED 239d0: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 239d4: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 239d8: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED 239dc: e5941010 ldr r1, [r4, #16] <== NOT EXECUTED 239e0: e1a00180 lsl r0, r0, #3 <== NOT EXECUTED 239e4: eb00dd3f bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
printf (" blocks used: %zd (%d.%d%%)\n",
239e8: e59f5094 ldr r5, [pc, #148] ; 23a84 <rtems_rfs_shell_data+0x200><== NOT EXECUTED 239ec: e0c23795 smull r3, r2, r5, r7 <== NOT EXECUTED 239f0: e1a03fc7 asr r3, r7, #31 <== NOT EXECUTED 239f4: e0632142 rsb r2, r3, r2, asr #2 <== NOT EXECUTED 239f8: e0823102 add r3, r2, r2, lsl #2 <== NOT EXECUTED
rtems_rfs_group_usage (fs, &blocks, &inodes);
rtems_rfs_shell_unlock_rfs (fs);
bpcent = (blocks * 1000) / rtems_rfs_fs_blocks (fs);
ipcent = (inodes * 1000) / rtems_rfs_fs_inodes (fs);
239fc: e1a04000 mov r4, r0 <== NOT EXECUTED
printf (" blocks used: %zd (%d.%d%%)\n",
23a00: e0473083 sub r3, r7, r3, lsl #1 <== NOT EXECUTED 23a04: e1a01006 mov r1, r6 <== NOT EXECUTED 23a08: e59f0078 ldr r0, [pc, #120] ; 23a88 <rtems_rfs_shell_data+0x204><== NOT EXECUTED 23a0c: eb008ed5 bl 47568 <printf> <== NOT EXECUTED
blocks, bpcent / 10, bpcent % 10);
printf (" inodes used: %zd (%d.%d%%)\n",
23a10: e0c23495 smull r3, r2, r5, r4 <== NOT EXECUTED 23a14: e1a03fc4 asr r3, r4, #31 <== NOT EXECUTED 23a18: e0632142 rsb r2, r3, r2, asr #2 <== NOT EXECUTED 23a1c: e0823102 add r3, r2, r2, lsl #2 <== NOT EXECUTED 23a20: e0443083 sub r3, r4, r3, lsl #1 <== NOT EXECUTED 23a24: e59d1000 ldr r1, [sp] <== NOT EXECUTED 23a28: e59f005c ldr r0, [pc, #92] ; 23a8c <rtems_rfs_shell_data+0x208><== NOT EXECUTED 23a2c: eb008ecd bl 47568 <printf> <== NOT EXECUTED
inodes, ipcent / 10, ipcent % 10);
return 0;
}
23a30: e3a00000 mov r0, #0 <== NOT EXECUTED
23a34: e28dd008 add sp, sp, #8 <== NOT EXECUTED
23a38: e8bd80f0 pop {r4, r5, r6, r7, pc} <== NOT EXECUTED
00023370 <rtems_rfs_shell_dir>:
return 0;
}
static int
rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
{
23370: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
bool state;
int entry;
int b;
int rc;
if (argc <= 1)
23374: e3510001 cmp r1, #1 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_dir (rtems_rfs_file_system* fs, int argc, char *argv[])
{
23378: e24dd020 sub sp, sp, #32 <== NOT EXECUTED 2337c: e1a07000 mov r7, r0 <== NOT EXECUTED
bool state;
int entry;
int b;
int rc;
if (argc <= 1)
23380: da0000aa ble 23630 <rtems_rfs_shell_dir+0x2c0> <== NOT EXECUTED
{
printf ("error: no block number provided\n");
return 1;
}
block = strtoul (argv[1], 0, 0);
23384: e3a01000 mov r1, #0 <== NOT EXECUTED 23388: e5920004 ldr r0, [r2, #4] <== NOT EXECUTED 2338c: e1a02001 mov r2, r1 <== NOT EXECUTED 23390: eb009f2f bl 4b054 <strtoul> <== NOT EXECUTED 23394: e597307c ldr r3, [r7, #124] ; 0x7c <== NOT EXECUTED 23398: e3a01000 mov r1, #0 <== NOT EXECUTED 2339c: e1a02001 mov r2, r1 <== NOT EXECUTED 233a0: e1a04000 mov r4, r0 <== NOT EXECUTED 233a4: e5930000 ldr r0, [r3] <== NOT EXECUTED 233a8: ebffa445 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
rtems_rfs_shell_lock_rfs (fs);
rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
233ac: e1a00007 mov r0, r7 <== NOT EXECUTED 233b0: e3a01000 mov r1, #0 <== NOT EXECUTED 233b4: e1a02004 mov r2, r4 <== NOT EXECUTED 233b8: e28d301f add r3, sp, #31 <== NOT EXECUTED 233bc: eb006583 bl 3c9d0 <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
if (rc > 0)
233c0: e2505000 subs r5, r0, #0 <== NOT EXECUTED 233c4: ca00006a bgt 23574 <rtems_rfs_shell_dir+0x204> <== NOT EXECUTED
printf ("error: testing block state: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
printf (" %5" PRIu32 ": block %s\n", block, state ? "allocated" : "free");
233c8: e5dd101f ldrb r1, [sp, #31] <== NOT EXECUTED 233cc: e59f3280 ldr r3, [pc, #640] ; 23654 <rtems_rfs_shell_dir+0x2e4><== NOT EXECUTED 233d0: e3510000 cmp r1, #0 <== NOT EXECUTED 233d4: e59f227c ldr r2, [pc, #636] ; 23658 <rtems_rfs_shell_dir+0x2e8><== NOT EXECUTED 233d8: e1a01004 mov r1, r4 <== NOT EXECUTED 233dc: 01a02003 moveq r2, r3 <== NOT EXECUTED 233e0: e59f0274 ldr r0, [pc, #628] ; 2365c <rtems_rfs_shell_dir+0x2ec><== NOT EXECUTED 233e4: eb00905f bl 47568 <printf> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
233e8: e3a08000 mov r8, #0 <== NOT EXECUTED
printf ("error: opening buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
233ec: e1a00007 mov r0, r7 <== NOT EXECUTED 233f0: e28d1010 add r1, sp, #16 <== NOT EXECUTED 233f4: e1a02004 mov r2, r4 <== NOT EXECUTED 233f8: e3a03001 mov r3, #1 <== NOT EXECUTED 233fc: e5cd8010 strb r8, [sp, #16] <== NOT EXECUTED
handle->bnum = 0;
23400: e58d8014 str r8, [sp, #20] <== NOT EXECUTED
handle->buffer = NULL;
23404: e58d8018 str r8, [sp, #24] <== NOT EXECUTED 23408: eb005991 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
2340c: e2505000 subs r5, r0, #0 <== NOT EXECUTED 23410: ca000075 bgt 235ec <rtems_rfs_shell_dir+0x27c> <== NOT EXECUTED
b = 0;
entry = 1;
data = rtems_rfs_buffer_data (&buffer);
while (b < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE - 1))
23414: e5973008 ldr r3, [r7, #8] <== NOT EXECUTED 23418: e353000b cmp r3, #11 <== NOT EXECUTED
return 1;
}
b = 0;
entry = 1;
data = rtems_rfs_buffer_data (&buffer);
2341c: e59d3018 ldr r3, [sp, #24] <== NOT EXECUTED 23420: e5935020 ldr r5, [r3, #32] <== NOT EXECUTED
while (b < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE - 1))
23424: 0a000065 beq 235c0 <rtems_rfs_shell_dir+0x250> <== NOT EXECUTED
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
elength = rtems_rfs_dir_entry_length (data);
23428: e5d53009 ldrb r3, [r5, #9] <== NOT EXECUTED 2342c: e5d56008 ldrb r6, [r5, #8] <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
23430: e3a0b801 mov fp, #65536 ; 0x10000 <== NOT EXECUTED
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
elength = rtems_rfs_dir_entry_length (data);
23434: e1836406 orr r6, r3, r6, lsl #8 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
23438: e24bb001 sub fp, fp, #1 <== NOT EXECUTED 2343c: e156000b cmp r6, fp <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
23440: e5d50000 ldrb r0, [r5] <== NOT EXECUTED 23444: e5d52001 ldrb r2, [r5, #1] <== NOT EXECUTED 23448: e5d53002 ldrb r3, [r5, #2] <== NOT EXECUTED 2344c: e5d51003 ldrb r1, [r5, #3] <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (data);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
23450: 0a00005a beq 235c0 <rtems_rfs_shell_dir+0x250> <== NOT EXECUTED
break;
if ((elength < RTEMS_RFS_DIR_ENTRY_SIZE) ||
23454: e3560009 cmp r6, #9 <== NOT EXECUTED 23458: d3a09001 movle r9, #1 <== NOT EXECUTED 2345c: da000053 ble 235b0 <rtems_rfs_shell_dir+0x240> <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
23460: e1811c00 orr r1, r1, r0, lsl #24 <== NOT EXECUTED 23464: e1812802 orr r2, r1, r2, lsl #16 <== NOT EXECUTED 23468: e1823403 orr r3, r2, r3, lsl #8 <== NOT EXECUTED 2346c: e3a09001 mov r9, #1 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if ((elength < RTEMS_RFS_DIR_ENTRY_SIZE) ||
(elength >= rtems_rfs_fs_max_name (fs)))
23470: e5972018 ldr r2, [r7, #24] <== NOT EXECUTED 23474: e1560002 cmp r6, r2 <== NOT EXECUTED 23478: 2a00004c bcs 235b0 <rtems_rfs_shell_dir+0x240> <== NOT EXECUTED
{
printf (" %5d: entry length appears corrupt: %d\n", entry, elength);
break;
}
if ((eino < RTEMS_RFS_ROOT_INO) || (eino >= rtems_rfs_fs_inodes (fs)))
2347c: e3530000 cmp r3, #0 <== NOT EXECUTED 23480: 0a00006e beq 23640 <rtems_rfs_shell_dir+0x2d0> <== NOT EXECUTED 23484: e5972010 ldr r2, [r7, #16] <== NOT EXECUTED 23488: e1520003 cmp r2, r3 <== NOT EXECUTED 2348c: 9a00006b bls 23640 <rtems_rfs_shell_dir+0x2d0> <== NOT EXECUTED
break;
}
length = elength - RTEMS_RFS_DIR_ENTRY_SIZE;
printf (" %5d: %04x inode=%-6" PRIu32 " hash=%08" PRIx32 " name[%03u]=",
23490: e5d5c005 ldrb ip, [r5, #5] <== NOT EXECUTED 23494: e5d52004 ldrb r2, [r5, #4] <== NOT EXECUTED 23498: e5d51007 ldrb r1, [r5, #7] <== NOT EXECUTED 2349c: e1a0c80c lsl ip, ip, #16 <== NOT EXECUTED 234a0: e18ccc02 orr ip, ip, r2, lsl #24 <== NOT EXECUTED 234a4: e5d52006 ldrb r2, [r5, #6] <== NOT EXECUTED 234a8: e18cc001 orr ip, ip, r1 <== NOT EXECUTED
{
printf (" %5d: entry ino appears corrupt: ino=%" PRId32 "\n", entry, eino);
break;
}
length = elength - RTEMS_RFS_DIR_ENTRY_SIZE;
234ac: e246a00a sub sl, r6, #10 <== NOT EXECUTED
printf (" %5d: %04x inode=%-6" PRIu32 " hash=%08" PRIx32 " name[%03u]=",
234b0: e18cc402 orr ip, ip, r2, lsl #8 <== NOT EXECUTED 234b4: e35a0032 cmp sl, #50 ; 0x32 <== NOT EXECUTED 234b8: b1a0400a movlt r4, sl <== NOT EXECUTED 234bc: a3a04032 movge r4, #50 ; 0x32 <== NOT EXECUTED 234c0: e59f0198 ldr r0, [pc, #408] ; 23660 <rtems_rfs_shell_dir+0x2f0><== NOT EXECUTED 234c4: e1a01009 mov r1, r9 <== NOT EXECUTED 234c8: e1a02008 mov r2, r8 <== NOT EXECUTED 234cc: e58dc000 str ip, [sp] <== NOT EXECUTED 234d0: e58da004 str sl, [sp, #4] <== NOT EXECUTED 234d4: eb009023 bl 47568 <printf> <== NOT EXECUTED
length);
if (length > 50)
length = 50;
for (c = 0; c < length; c++)
234d8: e3540000 cmp r4, #0 <== NOT EXECUTED 234dc: da00000b ble 23510 <rtems_rfs_shell_dir+0x1a0> <== NOT EXECUTED 234e0: e1a02005 mov r2, r5 <== NOT EXECUTED 234e4: e3a03000 mov r3, #0 <== NOT EXECUTED
printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
234e8: e5d2000a ldrb r0, [r2, #10] <== NOT EXECUTED
length);
if (length > 50)
length = 50;
for (c = 0; c < length; c++)
234ec: e2833001 add r3, r3, #1 <== NOT EXECUTED
printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
234f0: e58d200c str r2, [sp, #12] <== NOT EXECUTED 234f4: e58d3008 str r3, [sp, #8] <== NOT EXECUTED 234f8: eb00908f bl 4773c <putchar> <== NOT EXECUTED
length);
if (length > 50)
length = 50;
for (c = 0; c < length; c++)
234fc: e59d3008 ldr r3, [sp, #8] <== NOT EXECUTED 23500: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 23504: e1540003 cmp r4, r3 <== NOT EXECUTED 23508: e2822001 add r2, r2, #1 <== NOT EXECUTED 2350c: cafffff5 bgt 234e8 <rtems_rfs_shell_dir+0x178> <== NOT EXECUTED
printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
if (length < elength - RTEMS_RFS_DIR_ENTRY_SIZE)
23510: e15a0004 cmp sl, r4 <== NOT EXECUTED 23514: ca000022 bgt 235a4 <rtems_rfs_shell_dir+0x234> <== NOT EXECUTED
printf ("...");
printf ("\n");
23518: e3a0000a mov r0, #10 <== NOT EXECUTED 2351c: eb009086 bl 4773c <putchar> <== NOT EXECUTED
b = 0;
entry = 1;
data = rtems_rfs_buffer_data (&buffer);
while (b < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE - 1))
23520: e5973008 ldr r3, [r7, #8] <== NOT EXECUTED
printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
if (length < elength - RTEMS_RFS_DIR_ENTRY_SIZE)
printf ("...");
printf ("\n");
b += elength;
23524: e0888006 add r8, r8, r6 <== NOT EXECUTED
b = 0;
entry = 1;
data = rtems_rfs_buffer_data (&buffer);
while (b < (rtems_rfs_fs_block_size (fs) - RTEMS_RFS_DIR_ENTRY_SIZE - 1))
23528: e243300b sub r3, r3, #11 <== NOT EXECUTED 2352c: e1580003 cmp r8, r3 <== NOT EXECUTED 23530: 2a000022 bcs 235c0 <rtems_rfs_shell_dir+0x250> <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
23534: e7f50006 ldrb r0, [r5, r6]! <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (data);
23538: e5d52009 ldrb r2, [r5, #9] <== NOT EXECUTED 2353c: e5d56008 ldrb r6, [r5, #8] <== NOT EXECUTED 23540: e1826406 orr r6, r2, r6, lsl #8 <== NOT EXECUTED
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
23544: e156000b cmp r6, fp <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
23548: e5d51001 ldrb r1, [r5, #1] <== NOT EXECUTED 2354c: e5d52002 ldrb r2, [r5, #2] <== NOT EXECUTED 23550: e5d53003 ldrb r3, [r5, #3] <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (data);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
23554: 0a000019 beq 235c0 <rtems_rfs_shell_dir+0x250> <== NOT EXECUTED
break;
if ((elength < RTEMS_RFS_DIR_ENTRY_SIZE) ||
23558: e3560009 cmp r6, #9 <== NOT EXECUTED
printf ("...");
printf ("\n");
b += elength;
data += elength;
entry++;
2355c: e2899001 add r9, r9, #1 <== NOT EXECUTED
elength = rtems_rfs_dir_entry_length (data);
if (elength == RTEMS_RFS_DIR_ENTRY_EMPTY)
break;
if ((elength < RTEMS_RFS_DIR_ENTRY_SIZE) ||
23560: da000012 ble 235b0 <rtems_rfs_shell_dir+0x240> <== NOT EXECUTED
rtems_rfs_ino eino;
int elength;
int length;
int c;
eino = rtems_rfs_dir_entry_ino (data);
23564: e1833c00 orr r3, r3, r0, lsl #24 <== NOT EXECUTED 23568: e1833801 orr r3, r3, r1, lsl #16 <== NOT EXECUTED 2356c: e1833402 orr r3, r3, r2, lsl #8 <== NOT EXECUTED 23570: eaffffbe b 23470 <rtems_rfs_shell_dir+0x100> <== NOT EXECUTED
rtems_rfs_shell_lock_rfs (fs);
rc = rtems_rfs_group_bitmap_test (fs, false, block, &state);
if (rc > 0)
{
rtems_rfs_shell_unlock_rfs (fs);
23574: e1a00007 mov r0, r7 <== NOT EXECUTED 23578: ebfffde6 bl 22d18 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
printf ("error: testing block state: block=%" PRIu32 ": (%d) %s\n",
2357c: e1a00005 mov r0, r5 <== NOT EXECUTED 23580: eb00980b bl 495b4 <strerror> <== NOT EXECUTED 23584: e1a01004 mov r1, r4 <== NOT EXECUTED 23588: e1a03000 mov r3, r0 <== NOT EXECUTED 2358c: e1a02005 mov r2, r5 <== NOT EXECUTED 23590: e59f00cc ldr r0, [pc, #204] ; 23664 <rtems_rfs_shell_dir+0x2f4><== NOT EXECUTED 23594: eb008ff3 bl 47568 <printf> <== NOT EXECUTED 23598: e3a00001 mov r0, #1 <== NOT EXECUTED
}
rtems_rfs_shell_unlock_rfs (fs);
return 0;
}
2359c: e28dd020 add sp, sp, #32 <== NOT EXECUTED
235a0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
length = 50;
for (c = 0; c < length; c++)
printf ("%c", data[RTEMS_RFS_DIR_ENTRY_SIZE + c]);
if (length < elength - RTEMS_RFS_DIR_ENTRY_SIZE)
printf ("...");
235a4: e59f00bc ldr r0, [pc, #188] ; 23668 <rtems_rfs_shell_dir+0x2f8><== NOT EXECUTED 235a8: eb008fee bl 47568 <printf> <== NOT EXECUTED 235ac: eaffffd9 b 23518 <rtems_rfs_shell_dir+0x1a8> <== NOT EXECUTED
break;
if ((elength < RTEMS_RFS_DIR_ENTRY_SIZE) ||
(elength >= rtems_rfs_fs_max_name (fs)))
{
printf (" %5d: entry length appears corrupt: %d\n", entry, elength);
235b0: e1a01009 mov r1, r9 <== NOT EXECUTED 235b4: e1a02006 mov r2, r6 <== NOT EXECUTED 235b8: e59f00ac ldr r0, [pc, #172] ; 2366c <rtems_rfs_shell_dir+0x2fc><== NOT EXECUTED 235bc: eb008fe9 bl 47568 <printf> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
235c0: e28d1010 add r1, sp, #16 <== NOT EXECUTED 235c4: e1a00007 mov r0, r7 <== NOT EXECUTED 235c8: eb0058d7 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
handle->dirty = false;
235cc: e3a04000 mov r4, #0 <== NOT EXECUTED
printf ("error: closing buffer handle: block=%" PRIu32 ": (%d) %s\n",
block, rc, strerror (rc));
return 1;
}
rtems_rfs_shell_unlock_rfs (fs);
235d0: e1a00007 mov r0, r7 <== NOT EXECUTED 235d4: e5cd4010 strb r4, [sp, #16] <== NOT EXECUTED
handle->bnum = 0;
235d8: e58d4014 str r4, [sp, #20] <== NOT EXECUTED
handle->buffer = NULL;
235dc: e58d4018 str r4, [sp, #24] <== NOT EXECUTED 235e0: ebfffdcc bl 22d18 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED 235e4: e1a00004 mov r0, r4 <== NOT EXECUTED
return 0;
235e8: eaffffeb b 2359c <rtems_rfs_shell_dir+0x22c> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
235ec: e28d1010 add r1, sp, #16 <== NOT EXECUTED 235f0: e1a00007 mov r0, r7 <== NOT EXECUTED 235f4: eb0058cc bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, true);
if (rc > 0)
{
rtems_rfs_buffer_handle_close (fs, &buffer);
rtems_rfs_shell_unlock_rfs (fs);
235f8: e1a00007 mov r0, r7 <== NOT EXECUTED
handle->dirty = false; handle->bnum = 0; handle->buffer = NULL;
235fc: e58d8018 str r8, [sp, #24] <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
23600: e5cd8010 strb r8, [sp, #16] <== NOT EXECUTED
handle->bnum = 0;
23604: e58d8014 str r8, [sp, #20] <== NOT EXECUTED 23608: ebfffdc2 bl 22d18 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
printf ("error: requesting buffer handle: block=%" PRIu32 ": (%d) %s\n",
2360c: e1a00005 mov r0, r5 <== NOT EXECUTED 23610: eb0097e7 bl 495b4 <strerror> <== NOT EXECUTED 23614: e1a01004 mov r1, r4 <== NOT EXECUTED 23618: e1a03000 mov r3, r0 <== NOT EXECUTED 2361c: e1a02005 mov r2, r5 <== NOT EXECUTED 23620: e59f0048 ldr r0, [pc, #72] ; 23670 <rtems_rfs_shell_dir+0x300><== NOT EXECUTED 23624: eb008fcf bl 47568 <printf> <== NOT EXECUTED 23628: e3a00001 mov r0, #1 <== NOT EXECUTED
block, rc, strerror (rc));
return 1;
2362c: eaffffda b 2359c <rtems_rfs_shell_dir+0x22c> <== NOT EXECUTED
int b;
int rc;
if (argc <= 1)
{
printf ("error: no block number provided\n");
23630: e59f003c ldr r0, [pc, #60] ; 23674 <rtems_rfs_shell_dir+0x304><== NOT EXECUTED 23634: eb009070 bl 477fc <puts> <== NOT EXECUTED 23638: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
2363c: eaffffd6 b 2359c <rtems_rfs_shell_dir+0x22c> <== NOT EXECUTED
break;
}
if ((eino < RTEMS_RFS_ROOT_INO) || (eino >= rtems_rfs_fs_inodes (fs)))
{
printf (" %5d: entry ino appears corrupt: ino=%" PRId32 "\n", entry, eino);
23640: e1a01009 mov r1, r9 <== NOT EXECUTED 23644: e1a02003 mov r2, r3 <== NOT EXECUTED 23648: e59f0028 ldr r0, [pc, #40] ; 23678 <rtems_rfs_shell_dir+0x308><== NOT EXECUTED 2364c: eb008fc5 bl 47568 <printf> <== NOT EXECUTED
break;
23650: eaffffda b 235c0 <rtems_rfs_shell_dir+0x250> <== NOT EXECUTED
000231d8 <rtems_rfs_shell_group>:
return 0;
}
static int
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
{
231d8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
int g;
start = 0;
end = fs->group_count - 1;
switch (argc)
231dc: e3510002 cmp r1, #2 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_group (rtems_rfs_file_system* fs, int argc, char *argv[])
{
231e0: e24dd010 sub sp, sp, #16 <== NOT EXECUTED 231e4: e1a06000 mov r6, r0 <== NOT EXECUTED 231e8: e1a05002 mov r5, r2 <== NOT EXECUTED
int start;
int end;
int g;
start = 0;
end = fs->group_count - 1;
231ec: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED
switch (argc)
231f0: 0a000025 beq 2328c <rtems_rfs_shell_group+0xb4> <== NOT EXECUTED 231f4: e3510003 cmp r1, #3 <== NOT EXECUTED 231f8: 0a000015 beq 23254 <rtems_rfs_shell_group+0x7c> <== NOT EXECUTED 231fc: e3510001 cmp r1, #1 <== NOT EXECUTED 23200: 0a000004 beq 23218 <rtems_rfs_shell_group+0x40> <== NOT EXECUTED
case 3:
start = strtoul (argv[1], 0, 0);
end = strtoul (argv[2], 0, 0);
break;
default:
printf ("error: too many arguments.\n");
23204: e59f0158 ldr r0, [pc, #344] ; 23364 <rtems_rfs_shell_group+0x18c><== NOT EXECUTED 23208: eb00917b bl 477fc <puts> <== NOT EXECUTED 2320c: e3a00001 mov r0, #1 <== NOT EXECUTED
}
rtems_rfs_shell_unlock_rfs (fs);
return 0;
}
23210: e28dd010 add sp, sp, #16 <== NOT EXECUTED
23214: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
int start;
int end;
int g;
start = 0;
end = fs->group_count - 1;
23218: e2437001 sub r7, r3, #1 <== NOT EXECUTED 2321c: e3a02000 mov r2, #0 <== NOT EXECUTED 23220: e1a01fa7 lsr r1, r7, #31 <== NOT EXECUTED 23224: e1a04002 mov r4, r2 <== NOT EXECUTED
default:
printf ("error: too many arguments.\n");
return 1;
}
if ((start < 0) || (end < 0) ||
23228: e1911002 orrs r1, r1, r2 <== NOT EXECUTED 2322c: 1a000003 bne 23240 <rtems_rfs_shell_group+0x68> <== NOT EXECUTED 23230: e1540003 cmp r4, r3 <== NOT EXECUTED 23234: aa000001 bge 23240 <rtems_rfs_shell_group+0x68> <== NOT EXECUTED 23238: e1570003 cmp r7, r3 <== NOT EXECUTED 2323c: ba00001c blt 232b4 <rtems_rfs_shell_group+0xdc> <== NOT EXECUTED
(start >= fs->group_count) || (end >= fs->group_count))
{
printf ("error: group out of range (0->%d).\n", fs->group_count);
23240: e1a01003 mov r1, r3 <== NOT EXECUTED 23244: e59f011c ldr r0, [pc, #284] ; 23368 <rtems_rfs_shell_group+0x190><== NOT EXECUTED 23248: eb0090c6 bl 47568 <printf> <== NOT EXECUTED 2324c: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
23250: eaffffee b 23210 <rtems_rfs_shell_group+0x38> <== NOT EXECUTED
break;
case 2:
start = end = strtoul (argv[1], 0, 0);
break;
case 3:
start = strtoul (argv[1], 0, 0);
23254: e3a01000 mov r1, #0 <== NOT EXECUTED 23258: e1a02001 mov r2, r1 <== NOT EXECUTED 2325c: e5950004 ldr r0, [r5, #4] <== NOT EXECUTED 23260: eb009f7b bl 4b054 <strtoul> <== NOT EXECUTED
end = strtoul (argv[2], 0, 0);
23264: e3a01000 mov r1, #0 <== NOT EXECUTED 23268: e1a02001 mov r2, r1 <== NOT EXECUTED
break;
case 2:
start = end = strtoul (argv[1], 0, 0);
break;
case 3:
start = strtoul (argv[1], 0, 0);
2326c: e1a04000 mov r4, r0 <== NOT EXECUTED
end = strtoul (argv[2], 0, 0);
23270: e5950008 ldr r0, [r5, #8] <== NOT EXECUTED 23274: eb009f76 bl 4b054 <strtoul> <== NOT EXECUTED 23278: e1a02fa4 lsr r2, r4, #31 <== NOT EXECUTED 2327c: e1a07000 mov r7, r0 <== NOT EXECUTED 23280: e1a01fa0 lsr r1, r0, #31 <== NOT EXECUTED 23284: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED
break;
23288: eaffffe6 b 23228 <rtems_rfs_shell_group+0x50> <== NOT EXECUTED
switch (argc)
{
case 1:
break;
case 2:
start = end = strtoul (argv[1], 0, 0);
2328c: e3a01000 mov r1, #0 <== NOT EXECUTED 23290: e5920004 ldr r0, [r2, #4] <== NOT EXECUTED 23294: e1a02001 mov r2, r1 <== NOT EXECUTED 23298: eb009f6d bl 4b054 <strtoul> <== NOT EXECUTED 2329c: e1a02fa0 lsr r2, r0, #31 <== NOT EXECUTED 232a0: e1a07000 mov r7, r0 <== NOT EXECUTED 232a4: e5963020 ldr r3, [r6, #32] <== NOT EXECUTED 232a8: e1a01002 mov r1, r2 <== NOT EXECUTED 232ac: e1a04000 mov r4, r0 <== NOT EXECUTED
break;
232b0: eaffffdc b 23228 <rtems_rfs_shell_group+0x50> <== NOT EXECUTED 232b4: e596307c ldr r3, [r6, #124] ; 0x7c <== NOT EXECUTED 232b8: e1a02001 mov r2, r1 <== NOT EXECUTED 232bc: e5930000 ldr r0, [r3] <== NOT EXECUTED 232c0: ebffa47f bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (g = start; g <= end; g++)
232c4: e1540007 cmp r4, r7 <== NOT EXECUTED 232c8: ca000021 bgt 23354 <rtems_rfs_shell_group+0x17c> <== NOT EXECUTED 232cc: e0845104 add r5, r4, r4, lsl #2 <== NOT EXECUTED 232d0: e1a05205 lsl r5, r5, #4 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
232d4: e596201c ldr r2, [r6, #28] <== NOT EXECUTED 232d8: e0821005 add r1, r2, r5 <== NOT EXECUTED
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
232dc: e5918004 ldr r8, [r1, #4] <== NOT EXECUTED 232e0: e5913018 ldr r3, [r1, #24] <== NOT EXECUTED 232e4: e0633008 rsb r3, r3, r8 <== NOT EXECUTED
inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
232e8: e0830103 add r0, r3, r3, lsl #2 <== NOT EXECUTED 232ec: e0800100 add r0, r0, r0, lsl #2 <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
232f0: e591a03c ldr sl, [r1, #60] ; 0x3c <== NOT EXECUTED
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
232f4: e1a00100 lsl r0, r0, #2 <== NOT EXECUTED 232f8: e1a01008 mov r1, r8 <== NOT EXECUTED 232fc: e792b005 ldr fp, [r2, r5] <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
23300: e5969028 ldr r9, [r6, #40] ; 0x28 <== NOT EXECUTED
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
23304: e58d3000 str r3, [sp] <== NOT EXECUTED 23308: eb00def6 bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED
{
rtems_rfs_group* group = &fs->groups[g];
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
2330c: e06aa009 rsb sl, sl, r9 <== NOT EXECUTED
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
23310: e08a310a add r3, sl, sl, lsl #2 <== NOT EXECUTED 23314: e0833103 add r3, r3, r3, lsl #2 <== NOT EXECUTED 23318: e58d0004 str r0, [sp, #4] <== NOT EXECUTED 2331c: e1a01009 mov r1, r9 <== NOT EXECUTED 23320: e1a00103 lsl r0, r3, #2 <== NOT EXECUTED 23324: e58da008 str sl, [sp, #8] <== NOT EXECUTED 23328: eb00deee bl 5aee8 <__aeabi_uidiv> <== NOT EXECUTED 2332c: e1a01004 mov r1, r4 <== NOT EXECUTED 23330: e58d000c str r0, [sp, #12] <== NOT EXECUTED 23334: e1a0200b mov r2, fp <== NOT EXECUTED 23338: e1a03008 mov r3, r8 <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (g = start; g <= end; g++)
2333c: e2844001 add r4, r4, #1 <== NOT EXECUTED
rtems_rfs_group* group = &fs->groups[g];
size_t blocks;
size_t inodes;
blocks = group->size - rtems_rfs_bitmap_map_free (&group->block_bitmap);
inodes = fs->group_inodes - rtems_rfs_bitmap_map_free (&group->inode_bitmap);
printf (" %4d: base=%-7" PRIu32 " size=%-6zu blocks=%-5zu (%3zu%%) inode=%-5zu (%3zu%%)\n",
23340: e59f0024 ldr r0, [pc, #36] ; 2336c <rtems_rfs_shell_group+0x194><== NOT EXECUTED 23344: eb009087 bl 47568 <printf> <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (g = start; g <= end; g++)
23348: e1570004 cmp r7, r4 <== NOT EXECUTED 2334c: e2855050 add r5, r5, #80 ; 0x50 <== NOT EXECUTED 23350: aaffffdf bge 232d4 <rtems_rfs_shell_group+0xfc> <== NOT EXECUTED
g, group->base, group->size,
blocks, (blocks * 100) / group->size,
inodes, (inodes * 100) / fs->group_inodes);
}
rtems_rfs_shell_unlock_rfs (fs);
23354: e1a00006 mov r0, r6 <== NOT EXECUTED 23358: ebfffe6e bl 22d18 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED 2335c: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
23360: eaffffaa b 23210 <rtems_rfs_shell_group+0x38> <== NOT EXECUTED
00022d30 <rtems_rfs_shell_inode>:
return 0;
}
static int
rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
{
22d30: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
bool have_end;
int arg;
int b;
int rc;
total = fs->group_inodes * fs->group_count;
22d34: e5903020 ldr r3, [r0, #32] <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
{
22d38: e1a05000 mov r5, r0 <== NOT EXECUTED
bool have_end;
int arg;
int b;
int rc;
total = fs->group_inodes * fs->group_count;
22d3c: e5900028 ldr r0, [r0, #40] ; 0x28 <== NOT EXECUTED 22d40: e0030390 mul r3, r0, r3 <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
{
22d44: e24dd04c sub sp, sp, #76 ; 0x4c <== NOT EXECUTED
int b;
int rc;
total = fs->group_inodes * fs->group_count;
start = RTEMS_RFS_ROOT_INO;
end = total - 1;
22d48: e2430001 sub r0, r3, #1 <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
for (arg = 1; arg < argc; arg++)
22d4c: e3510001 cmp r1, #1 <== NOT EXECUTED
bool have_end;
int arg;
int b;
int rc;
total = fs->group_inodes * fs->group_count;
22d50: e58d300c str r3, [sp, #12] <== NOT EXECUTED
return 0;
}
static int
rtems_rfs_shell_inode (rtems_rfs_file_system* fs, int argc, char *argv[])
{
22d54: e1a08001 mov r8, r1 <== NOT EXECUTED 22d58: e1a09002 mov r9, r2 <== NOT EXECUTED
int b;
int rc;
total = fs->group_inodes * fs->group_count;
start = RTEMS_RFS_ROOT_INO;
end = total - 1;
22d5c: e58d001c str r0, [sp, #28] <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
for (arg = 1; arg < argc; arg++)
22d60: da000104 ble 23178 <rtems_rfs_shell_inode+0x448> <== NOT EXECUTED 22d64: e3a07000 mov r7, #0 <== NOT EXECUTED 22d68: e3a04001 mov r4, #1 <== NOT EXECUTED 22d6c: e59d601c ldr r6, [sp, #28] <== NOT EXECUTED 22d70: e1a0a007 mov sl, r7 <== NOT EXECUTED 22d74: e58d7018 str r7, [sp, #24] <== NOT EXECUTED 22d78: e58d7014 str r7, [sp, #20] <== NOT EXECUTED 22d7c: e1a0b007 mov fp, r7 <== NOT EXECUTED 22d80: e58d4010 str r4, [sp, #16] <== NOT EXECUTED 22d84: ea00000a b 22db4 <rtems_rfs_shell_inode+0x84> <== NOT EXECUTED
break;
}
}
else
{
if (have_end && have_start)
22d88: e35a0000 cmp sl, #0 <== NOT EXECUTED 22d8c: 1a0000c2 bne 2309c <rtems_rfs_shell_inode+0x36c> <== NOT EXECUTED
printf ("warning: option ignored: %s\n", argv[arg]);
else if (!have_start)
{
start = end = strtoul (argv[arg], 0, 0);
22d90: e3a01000 mov r1, #0 <== NOT EXECUTED 22d94: e1a02001 mov r2, r1 <== NOT EXECUTED 22d98: eb00a0ad bl 4b054 <strtoul> <== NOT EXECUTED 22d9c: e58d0010 str r0, [sp, #16] <== NOT EXECUTED 22da0: e1a06000 mov r6, r0 <== NOT EXECUTED 22da4: e3a0a001 mov sl, #1 <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
for (arg = 1; arg < argc; arg++)
22da8: e2844001 add r4, r4, #1 <== NOT EXECUTED 22dac: e1580004 cmp r8, r4 <== NOT EXECUTED 22db0: da00000f ble 22df4 <rtems_rfs_shell_inode+0xc4> <== NOT EXECUTED
{
if (argv[arg][0] == '-')
22db4: e7990104 ldr r0, [r9, r4, lsl #2] <== NOT EXECUTED 22db8: e5d03000 ldrb r3, [r0] <== NOT EXECUTED 22dbc: e353002d cmp r3, #45 ; 0x2d <== NOT EXECUTED 22dc0: 0a0000aa beq 23070 <rtems_rfs_shell_inode+0x340> <== NOT EXECUTED
break;
}
}
else
{
if (have_end && have_start)
22dc4: e3570000 cmp r7, #0 <== NOT EXECUTED 22dc8: 1affffee bne 22d88 <rtems_rfs_shell_inode+0x58> <== NOT EXECUTED
printf ("warning: option ignored: %s\n", argv[arg]);
else if (!have_start)
22dcc: e35a0000 cmp sl, #0 <== NOT EXECUTED 22dd0: 0affffee beq 22d90 <rtems_rfs_shell_inode+0x60> <== NOT EXECUTED
start = end = strtoul (argv[arg], 0, 0);
have_start = true;
}
else
{
end = strtoul (argv[arg], 0, 0);
22dd4: e1a01007 mov r1, r7 <== NOT EXECUTED 22dd8: e1a02007 mov r2, r7 <== NOT EXECUTED 22ddc: eb00a09c bl 4b054 <strtoul> <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
for (arg = 1; arg < argc; arg++)
22de0: e2844001 add r4, r4, #1 <== NOT EXECUTED 22de4: e1580004 cmp r8, r4 <== NOT EXECUTED
start = end = strtoul (argv[arg], 0, 0);
have_start = true;
}
else
{
end = strtoul (argv[arg], 0, 0);
22de8: e1a06000 mov r6, r0 <== NOT EXECUTED 22dec: e3a07001 mov r7, #1 <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
for (arg = 1; arg < argc; arg++)
22df0: caffffef bgt 22db4 <rtems_rfs_shell_inode+0x84> <== NOT EXECUTED
have_end = true;
}
}
}
if ((start >= total) || (end >= total))
22df4: e28d200c add r2, sp, #12 <== NOT EXECUTED
22df8: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
22dfc: e1530002 cmp r3, r2 <== NOT EXECUTED
22e00: 31560002 cmpcc r6, r2 <== NOT EXECUTED
22e04: 33a01000 movcc r1, #0 <== NOT EXECUTED
22e08: 23a01001 movcs r1, #1 <== NOT EXECUTED
22e0c: 2a0000bb bcs 23100 <rtems_rfs_shell_inode+0x3d0> <== NOT EXECUTED
*/
static inline int
rtems_rfs_mutex_lock (rtems_rfs_mutex* mutex)
{
#if __rtems__
rtems_status_code sc = rtems_semaphore_obtain (*mutex, RTEMS_WAIT, 0);
22e10: e595307c ldr r3, [r5, #124] ; 0x7c <== NOT EXECUTED 22e14: e1a02001 mov r2, r1 <== NOT EXECUTED 22e18: e5930000 ldr r0, [r3] <== NOT EXECUTED 22e1c: ebffa5a8 bl c4c4 <rtems_semaphore_obtain> <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (ino = start; ino <= end; ino++)
22e20: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 22e24: e1530006 cmp r3, r6 <== NOT EXECUTED 22e28: 8a00008c bhi 23060 <rtems_rfs_shell_inode+0x330> <== NOT EXECUTED
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
if (links == 0xffff)
22e2c: e3a00801 mov r0, #65536 ; 0x10000 <== NOT EXECUTED 22e30: e2400001 sub r0, r0, #1 <== NOT EXECUTED 22e34: e58d000c str r0, [sp, #12] <== NOT EXECUTED 22e38: e1a04003 mov r4, r3 <== NOT EXECUTED 22e3c: e28da04b add sl, sp, #75 ; 0x4b <== NOT EXECUTED
if (show_all || allocated)
{
uint16_t mode;
bool error;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
22e40: e28d8020 add r8, sp, #32 <== NOT EXECUTED 22e44: e1a09006 mov r9, r6 <== NOT EXECUTED
for (ino = start; ino <= end; ino++)
{
rtems_rfs_inode_handle inode;
bool allocated;
rc = rtems_rfs_group_bitmap_test (fs, true, ino, &allocated);
22e48: e1a00005 mov r0, r5 <== NOT EXECUTED 22e4c: e3a01001 mov r1, #1 <== NOT EXECUTED 22e50: e1a02004 mov r2, r4 <== NOT EXECUTED 22e54: e1a0300a mov r3, sl <== NOT EXECUTED 22e58: eb0066dc bl 3c9d0 <rtems_rfs_group_bitmap_test> <== NOT EXECUTED
if (rc > 0)
22e5c: e3500000 cmp r0, #0 <== NOT EXECUTED 22e60: ca0000ac bgt 23118 <rtems_rfs_shell_inode+0x3e8> <== NOT EXECUTED
printf ("error: testing inode state: ino=%" PRIu32 ": (%d) %s\n",
ino, rc, strerror (rc));
return 1;
}
if (show_all || allocated)
22e64: e35b0000 cmp fp, #0 <== NOT EXECUTED 22e68: 1a000002 bne 22e78 <rtems_rfs_shell_inode+0x148> <== NOT EXECUTED 22e6c: e5dd304b ldrb r3, [sp, #75] ; 0x4b <== NOT EXECUTED 22e70: e3530000 cmp r3, #0 <== NOT EXECUTED 22e74: 0a000076 beq 23054 <rtems_rfs_shell_inode+0x324> <== NOT EXECUTED
{
uint16_t mode;
bool error;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
22e78: e1a00005 mov r0, r5 <== NOT EXECUTED 22e7c: e1a01004 mov r1, r4 <== NOT EXECUTED 22e80: e1a02008 mov r2, r8 <== NOT EXECUTED 22e84: e3a03001 mov r3, #1 <== NOT EXECUTED 22e88: eb0068f5 bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
22e8c: e3500000 cmp r0, #0 <== NOT EXECUTED 22e90: ca0000ac bgt 23148 <rtems_rfs_shell_inode+0x418> <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
22e94: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED
error = false;
mode = rtems_rfs_inode_get_mode (&inode);
if (error_check_only)
22e98: e59d1014 ldr r1, [sp, #20] <== NOT EXECUTED 22e9c: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED 22ea0: e5d36002 ldrb r6, [r3, #2] <== NOT EXECUTED 22ea4: e3510000 cmp r1, #0 <== NOT EXECUTED 22ea8: e1826406 orr r6, r2, r6, lsl #8 <== NOT EXECUTED 22eac: 0a000009 beq 22ed8 <rtems_rfs_shell_inode+0x1a8> <== NOT EXECUTED
{
if (!RTEMS_RFS_S_ISDIR (mode) &&
22eb0: e2063a0f and r3, r6, #61440 ; 0xf000 <== NOT EXECUTED 22eb4: e3530a02 cmp r3, #8192 ; 0x2000 <== NOT EXECUTED 22eb8: 13530901 cmpne r3, #16384 ; 0x4000 <== NOT EXECUTED 22ebc: 0a00005f beq 23040 <rtems_rfs_shell_inode+0x310> <== NOT EXECUTED 22ec0: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED 22ec4: 0a00005d beq 23040 <rtems_rfs_shell_inode+0x310> <== NOT EXECUTED 22ec8: e3530902 cmp r3, #32768 ; 0x8000 <== NOT EXECUTED 22ecc: 0a00005b beq 23040 <rtems_rfs_shell_inode+0x310> <== NOT EXECUTED
}
#endif
}
}
if (!error_check_only || error)
22ed0: e3530a0a cmp r3, #40960 ; 0xa000 <== NOT EXECUTED 22ed4: 0a000059 beq 23040 <rtems_rfs_shell_inode+0x310> <== NOT EXECUTED
{
printf (" %5" PRIu32 ": pos=%06" PRIu32 ":%04zx %c ",
22ed8: e5ddc04b ldrb ip, [sp, #75] ; 0x4b <== NOT EXECUTED 22edc: e59d3040 ldr r3, [sp, #64] ; 0x40 <== NOT EXECUTED 22ee0: e35c0000 cmp ip, #0 <== NOT EXECUTED 22ee4: e1a02303 lsl r2, r3, #6 <== NOT EXECUTED 22ee8: 13a0c041 movne ip, #65 ; 0x41 <== NOT EXECUTED 22eec: 03a0c046 moveq ip, #70 ; 0x46 <== NOT EXECUTED 22ef0: e0423183 sub r3, r2, r3, lsl #3 <== NOT EXECUTED 22ef4: e59f029c ldr r0, [pc, #668] ; 23198 <rtems_rfs_shell_inode+0x468><== NOT EXECUTED 22ef8: e59d2034 ldr r2, [sp, #52] ; 0x34 <== NOT EXECUTED 22efc: e1a01004 mov r1, r4 <== NOT EXECUTED 22f00: e58dc000 str ip, [sp] <== NOT EXECUTED 22f04: eb009197 bl 47568 <printf> <== NOT EXECUTED
ino, rtems_rfs_buffer_bnum (&inode.buffer),
inode.offset * RTEMS_RFS_INODE_SIZE,
allocated ? 'A' : 'F');
if (!allocated && !forced)
22f08: e5dd304b ldrb r3, [sp, #75] ; 0x4b <== NOT EXECUTED 22f0c: e3530000 cmp r3, #0 <== NOT EXECUTED 22f10: 1a000002 bne 22f20 <rtems_rfs_shell_inode+0x1f0> <== NOT EXECUTED 22f14: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 22f18: e3520000 cmp r2, #0 <== NOT EXECUTED 22f1c: 0a000064 beq 230b4 <rtems_rfs_shell_inode+0x384> <== NOT EXECUTED
printf (" --\n");
else
{
const char* type;
type = "UKN";
if (RTEMS_RFS_S_ISDIR (mode))
22f20: e2063a0f and r3, r6, #61440 ; 0xf000 <== NOT EXECUTED 22f24: e3530901 cmp r3, #16384 ; 0x4000 <== NOT EXECUTED 22f28: 059f326c ldreq r3, [pc, #620] ; 2319c <rtems_rfs_shell_inode+0x46c><== NOT EXECUTED 22f2c: 0a00000d beq 22f68 <rtems_rfs_shell_inode+0x238> <== NOT EXECUTED
type = "DIR";
else if (RTEMS_RFS_S_ISCHR (mode))
22f30: e3530a02 cmp r3, #8192 ; 0x2000 <== NOT EXECUTED 22f34: 059f3264 ldreq r3, [pc, #612] ; 231a0 <rtems_rfs_shell_inode+0x470><== NOT EXECUTED 22f38: 0a00000a beq 22f68 <rtems_rfs_shell_inode+0x238> <== NOT EXECUTED
type = "CHR";
else if (RTEMS_RFS_S_ISBLK (mode))
22f3c: e3530a06 cmp r3, #24576 ; 0x6000 <== NOT EXECUTED 22f40: 059f325c ldreq r3, [pc, #604] ; 231a4 <rtems_rfs_shell_inode+0x474><== NOT EXECUTED 22f44: 0a000007 beq 22f68 <rtems_rfs_shell_inode+0x238> <== NOT EXECUTED
type = "BLK";
else if (RTEMS_RFS_S_ISREG (mode))
22f48: e3530902 cmp r3, #32768 ; 0x8000 <== NOT EXECUTED 22f4c: 059f3254 ldreq r3, [pc, #596] ; 231a8 <rtems_rfs_shell_inode+0x478><== NOT EXECUTED 22f50: 0a000004 beq 22f68 <rtems_rfs_shell_inode+0x238> <== NOT EXECUTED
type = "REG";
else if (RTEMS_RFS_S_ISLNK (mode))
22f54: e59f1250 ldr r1, [pc, #592] ; 231ac <rtems_rfs_shell_inode+0x47c><== NOT EXECUTED 22f58: e59f0250 ldr r0, [pc, #592] ; 231b0 <rtems_rfs_shell_inode+0x480><== NOT EXECUTED 22f5c: e3530a0a cmp r3, #40960 ; 0xa000 <== NOT EXECUTED 22f60: 01a00001 moveq r0, r1 <== NOT EXECUTED 22f64: e1a03000 mov r3, r0 <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
22f68: e59d002c ldr r0, [sp, #44] ; 0x2c <== NOT EXECUTED
type = "LNK";
printf ("links=%03i mode=%04x (%s/%03o) bo=%04u bc=%04" PRIu32 " b=[",
22f6c: e1a02b06 lsl r2, r6, #22 <== NOT EXECUTED 22f70: e1a02b22 lsr r2, r2, #22 <== NOT EXECUTED 22f74: e5d0e000 ldrb lr, [r0] <== NOT EXECUTED 22f78: e5d01001 ldrb r1, [r0, #1] <== NOT EXECUTED 22f7c: e58d2000 str r2, [sp] <== NOT EXECUTED 22f80: e5d0c00a ldrb ip, [r0, #10] <== NOT EXECUTED 22f84: e5d0200b ldrb r2, [r0, #11] <== NOT EXECUTED 22f88: e182240c orr r2, r2, ip, lsl #8 <== NOT EXECUTED 22f8c: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
22f90: e280200c add r2, r0, #12 <== NOT EXECUTED 22f94: e5d2c003 ldrb ip, [r2, #3] <== NOT EXECUTED 22f98: e5d0700c ldrb r7, [r0, #12] <== NOT EXECUTED 22f9c: e5d20001 ldrb r0, [r2, #1] <== NOT EXECUTED 22fa0: e18c7c07 orr r7, ip, r7, lsl #24 <== NOT EXECUTED 22fa4: e5d22002 ldrb r2, [r2, #2] <== NOT EXECUTED 22fa8: e187c800 orr ip, r7, r0, lsl #16 <== NOT EXECUTED 22fac: e18cc402 orr ip, ip, r2, lsl #8 <== NOT EXECUTED 22fb0: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
22fb4: e181140e orr r1, r1, lr, lsl #8 <== NOT EXECUTED 22fb8: e1510002 cmp r1, r2 <== NOT EXECUTED 22fbc: 03a01000 moveq r1, #0 <== NOT EXECUTED 22fc0: e1a02006 mov r2, r6 <== NOT EXECUTED 22fc4: e59f01e8 ldr r0, [pc, #488] ; 231b4 <rtems_rfs_shell_inode+0x484><== NOT EXECUTED 22fc8: e58dc008 str ip, [sp, #8] <== NOT EXECUTED 22fcc: eb009165 bl 47568 <printf> <== NOT EXECUTED 22fd0: e3a06000 mov r6, #0 <== NOT EXECUTED
* @return uint32_t The block number.
*/
static inline uint32_t
rtems_rfs_inode_get_block (rtems_rfs_inode_handle* handle, int block)
{
return rtems_rfs_read_u32 (&handle->node->data.blocks[block]);
22fd4: e59d202c ldr r2, [sp, #44] ; 0x2c <== NOT EXECUTED 22fd8: e282201c add r2, r2, #28 <== NOT EXECUTED
rtems_rfs_inode_get_links (&inode),
mode, type, mode & ((1 << 10) - 1),
rtems_rfs_inode_get_block_offset (&inode),
rtems_rfs_inode_get_block_count (&inode));
for (b = 0; b < (RTEMS_RFS_INODE_BLOCKS - 1); b++)
printf ("%" PRIu32 " ", rtems_rfs_inode_get_block (&inode, b));
22fdc: e0823006 add r3, r2, r6 <== NOT EXECUTED 22fe0: e7d21006 ldrb r1, [r2, r6] <== NOT EXECUTED 22fe4: e5d32003 ldrb r2, [r3, #3] <== NOT EXECUTED 22fe8: e5d30001 ldrb r0, [r3, #1] <== NOT EXECUTED 22fec: e1822c01 orr r2, r2, r1, lsl #24 <== NOT EXECUTED 22ff0: e5d31002 ldrb r1, [r3, #2] <== NOT EXECUTED 22ff4: e1823800 orr r3, r2, r0, lsl #16 <== NOT EXECUTED 22ff8: e1831401 orr r1, r3, r1, lsl #8 <== NOT EXECUTED 22ffc: e2866004 add r6, r6, #4 <== NOT EXECUTED 23000: e59f01b0 ldr r0, [pc, #432] ; 231b8 <rtems_rfs_shell_inode+0x488><== NOT EXECUTED 23004: eb009157 bl 47568 <printf> <== NOT EXECUTED
printf ("links=%03i mode=%04x (%s/%03o) bo=%04u bc=%04" PRIu32 " b=[",
rtems_rfs_inode_get_links (&inode),
mode, type, mode & ((1 << 10) - 1),
rtems_rfs_inode_get_block_offset (&inode),
rtems_rfs_inode_get_block_count (&inode));
for (b = 0; b < (RTEMS_RFS_INODE_BLOCKS - 1); b++)
23008: e3560010 cmp r6, #16 <== NOT EXECUTED 2300c: 1afffff0 bne 22fd4 <rtems_rfs_shell_inode+0x2a4> <== NOT EXECUTED 23010: e59d302c ldr r3, [sp, #44] ; 0x2c <== NOT EXECUTED 23014: e283301c add r3, r3, #28 <== NOT EXECUTED
printf ("%" PRIu32 " ", rtems_rfs_inode_get_block (&inode, b));
printf ("%" PRIu32 "]\n", rtems_rfs_inode_get_block (&inode, b));
23018: e5d30011 ldrb r0, [r3, #17] <== NOT EXECUTED 2301c: e5d31010 ldrb r1, [r3, #16] <== NOT EXECUTED 23020: e1a00800 lsl r0, r0, #16 <== NOT EXECUTED 23024: e5d32013 ldrb r2, [r3, #19] <== NOT EXECUTED 23028: e1800c01 orr r0, r0, r1, lsl #24 <== NOT EXECUTED 2302c: e5d31012 ldrb r1, [r3, #18] <== NOT EXECUTED 23030: e1803002 orr r3, r0, r2 <== NOT EXECUTED 23034: e1831401 orr r1, r3, r1, lsl #8 <== NOT EXECUTED 23038: e59f017c ldr r0, [pc, #380] ; 231bc <rtems_rfs_shell_inode+0x48c><== NOT EXECUTED 2303c: eb009149 bl 47568 <printf> <== NOT EXECUTED
}
}
rc = rtems_rfs_inode_close (fs, &inode);
23040: e1a00005 mov r0, r5 <== NOT EXECUTED 23044: e1a01008 mov r1, r8 <== NOT EXECUTED 23048: eb006861 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
2304c: e3500000 cmp r0, #0 <== NOT EXECUTED 23050: ca00001e bgt 230d0 <rtems_rfs_shell_inode+0x3a0> <== NOT EXECUTED
return 1;
}
rtems_rfs_shell_lock_rfs (fs);
for (ino = start; ino <= end; ino++)
23054: e2844001 add r4, r4, #1 <== NOT EXECUTED 23058: e1540009 cmp r4, r9 <== NOT EXECUTED 2305c: 9affff79 bls 22e48 <rtems_rfs_shell_inode+0x118> <== NOT EXECUTED
return 1;
}
}
}
rtems_rfs_shell_unlock_rfs (fs);
23060: e1a00005 mov r0, r5 <== NOT EXECUTED 23064: ebffff2b bl 22d18 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED 23068: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
2306c: ea000027 b 23110 <rtems_rfs_shell_inode+0x3e0> <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
23070: e5d03001 ldrb r3, [r0, #1] <== NOT EXECUTED 23074: e3530065 cmp r3, #101 ; 0x65 <== NOT EXECUTED 23078: 03a03001 moveq r3, #1 <== NOT EXECUTED 2307c: 058d3014 streq r3, [sp, #20] <== NOT EXECUTED 23080: 0affff48 beq 22da8 <rtems_rfs_shell_inode+0x78> <== NOT EXECUTED 23084: e3530066 cmp r3, #102 ; 0x66 <== NOT EXECUTED 23088: 03a00001 moveq r0, #1 <== NOT EXECUTED 2308c: 058d0018 streq r0, [sp, #24] <== NOT EXECUTED 23090: 0affff44 beq 22da8 <rtems_rfs_shell_inode+0x78> <== NOT EXECUTED 23094: e3530061 cmp r3, #97 ; 0x61 <== NOT EXECUTED 23098: 0a000003 beq 230ac <rtems_rfs_shell_inode+0x37c> <== NOT EXECUTED
}
}
else
{
if (have_end && have_start)
printf ("warning: option ignored: %s\n", argv[arg]);
2309c: e1a01000 mov r1, r0 <== NOT EXECUTED 230a0: e59f0118 ldr r0, [pc, #280] ; 231c0 <rtems_rfs_shell_inode+0x490><== NOT EXECUTED 230a4: eb00912f bl 47568 <printf> <== NOT EXECUTED
break;
}
}
else
{
if (have_end && have_start)
230a8: eaffff3e b 22da8 <rtems_rfs_shell_inode+0x78> <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
230ac: e3a0b001 mov fp, #1 <== NOT EXECUTED 230b0: eaffff3c b 22da8 <rtems_rfs_shell_inode+0x78> <== NOT EXECUTED
ino, rtems_rfs_buffer_bnum (&inode.buffer),
inode.offset * RTEMS_RFS_INODE_SIZE,
allocated ? 'A' : 'F');
if (!allocated && !forced)
printf (" --\n");
230b4: e59f0108 ldr r0, [pc, #264] ; 231c4 <rtems_rfs_shell_inode+0x494><== NOT EXECUTED 230b8: eb0091cf bl 477fc <puts> <== NOT EXECUTED
printf ("%" PRIu32 " ", rtems_rfs_inode_get_block (&inode, b));
printf ("%" PRIu32 "]\n", rtems_rfs_inode_get_block (&inode, b));
}
}
rc = rtems_rfs_inode_close (fs, &inode);
230bc: e1a00005 mov r0, r5 <== NOT EXECUTED 230c0: e1a01008 mov r1, r8 <== NOT EXECUTED 230c4: eb006842 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
230c8: e3500000 cmp r0, #0 <== NOT EXECUTED 230cc: daffffe0 ble 23054 <rtems_rfs_shell_inode+0x324> <== NOT EXECUTED 230d0: e1a07000 mov r7, r0 <== NOT EXECUTED
{
rtems_rfs_shell_unlock_rfs (fs);
230d4: e1a00005 mov r0, r5 <== NOT EXECUTED 230d8: ebffff0e bl 22d18 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
printf ("error: closing inode handle: ino=%" PRIu32 ": (%d) %s\n",
230dc: e1a00007 mov r0, r7 <== NOT EXECUTED 230e0: eb009933 bl 495b4 <strerror> <== NOT EXECUTED 230e4: e1a01004 mov r1, r4 <== NOT EXECUTED 230e8: e1a03000 mov r3, r0 <== NOT EXECUTED 230ec: e1a02007 mov r2, r7 <== NOT EXECUTED 230f0: e59f00d0 ldr r0, [pc, #208] ; 231c8 <rtems_rfs_shell_inode+0x498><== NOT EXECUTED 230f4: eb00911b bl 47568 <printf> <== NOT EXECUTED 230f8: e3a00001 mov r0, #1 <== NOT EXECUTED
ino, rc, strerror (rc));
return 1;
230fc: ea000003 b 23110 <rtems_rfs_shell_inode+0x3e0> <== NOT EXECUTED
}
}
if ((start >= total) || (end >= total))
{
printf ("error: inode out of range (0->%" PRId32 ").\n", total - 1);
23100: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 23104: e59f00c0 ldr r0, [pc, #192] ; 231cc <rtems_rfs_shell_inode+0x49c><== NOT EXECUTED 23108: eb009116 bl 47568 <printf> <== NOT EXECUTED 2310c: e3a00001 mov r0, #1 <== NOT EXECUTED
}
rtems_rfs_shell_unlock_rfs (fs);
return 0;
}
23110: e28dd04c add sp, sp, #76 ; 0x4c <== NOT EXECUTED
23114: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
23118: e1a07000 mov r7, r0 <== NOT EXECUTED
bool allocated;
rc = rtems_rfs_group_bitmap_test (fs, true, ino, &allocated);
if (rc > 0)
{
rtems_rfs_shell_unlock_rfs (fs);
2311c: e1a00005 mov r0, r5 <== NOT EXECUTED 23120: ebfffefc bl 22d18 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
printf ("error: testing inode state: ino=%" PRIu32 ": (%d) %s\n",
23124: e1a00007 mov r0, r7 <== NOT EXECUTED 23128: eb009921 bl 495b4 <strerror> <== NOT EXECUTED 2312c: e1a01004 mov r1, r4 <== NOT EXECUTED 23130: e1a03000 mov r3, r0 <== NOT EXECUTED 23134: e1a02007 mov r2, r7 <== NOT EXECUTED 23138: e59f0090 ldr r0, [pc, #144] ; 231d0 <rtems_rfs_shell_inode+0x4a0><== NOT EXECUTED 2313c: eb009109 bl 47568 <printf> <== NOT EXECUTED 23140: e3a00001 mov r0, #1 <== NOT EXECUTED
ino, rc, strerror (rc));
return 1;
23144: eafffff1 b 23110 <rtems_rfs_shell_inode+0x3e0> <== NOT EXECUTED 23148: e1a07000 mov r7, r0 <== NOT EXECUTED
bool error;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
if (rc > 0)
{
rtems_rfs_shell_unlock_rfs (fs);
2314c: e1a00005 mov r0, r5 <== NOT EXECUTED 23150: ebfffef0 bl 22d18 <rtems_rfs_shell_unlock_rfs> <== NOT EXECUTED
printf ("error: opening inode handle: ino=%" PRIu32 ": (%d) %s\n",
23154: e1a00007 mov r0, r7 <== NOT EXECUTED 23158: eb009915 bl 495b4 <strerror> <== NOT EXECUTED 2315c: e1a01004 mov r1, r4 <== NOT EXECUTED 23160: e1a03000 mov r3, r0 <== NOT EXECUTED 23164: e1a02007 mov r2, r7 <== NOT EXECUTED 23168: e59f0064 ldr r0, [pc, #100] ; 231d4 <rtems_rfs_shell_inode+0x4a4><== NOT EXECUTED 2316c: eb0090fd bl 47568 <printf> <== NOT EXECUTED 23170: e3a00001 mov r0, #1 <== NOT EXECUTED
ino, rc, strerror (rc));
return 1;
23174: eaffffe5 b 23110 <rtems_rfs_shell_inode+0x3e0> <== NOT EXECUTED
show_all = false;
error_check_only = false;
forced = false;
have_start = have_end = false;
for (arg = 1; arg < argc; arg++)
23178: e3a01000 mov r1, #0 <== NOT EXECUTED 2317c: e3a02001 mov r2, #1 <== NOT EXECUTED 23180: e58d1018 str r1, [sp, #24] <== NOT EXECUTED 23184: e1a06000 mov r6, r0 <== NOT EXECUTED 23188: e58d1014 str r1, [sp, #20] <== NOT EXECUTED 2318c: e1a0b001 mov fp, r1 <== NOT EXECUTED 23190: e58d2010 str r2, [sp, #16] <== NOT EXECUTED 23194: eaffff16 b 22df4 <rtems_rfs_shell_inode+0xc4> <== NOT EXECUTED
00022d18 <rtems_rfs_shell_unlock_rfs>:
/**
* Unlock the file system.
*/
static void
rtems_rfs_shell_unlock_rfs (rtems_rfs_file_system* fs)
{
22d18: e92d4010 push {r4, lr} <== NOT EXECUTED
* Unlock the RFS file system.
*/
static inline void
rtems_rfs_rtems_unlock (rtems_rfs_file_system* fs)
{
rtems_rfs_rtems_private* rtems = rtems_rfs_fs_user (fs);
22d1c: e590407c ldr r4, [r0, #124] ; 0x7c <== NOT EXECUTED
rtems_rfs_buffers_release (fs);
22d20: eb005aab bl 397d4 <rtems_rfs_buffers_release> <== NOT EXECUTED 22d24: e5940000 ldr r0, [r4] <== NOT EXECUTED
#if __rtems__ rtems_rfs_rtems_unlock (fs); #endif }
22d28: e8bd4010 pop {r4, lr} <== NOT EXECUTED
22d2c: eaffa62c b c5e4 <rtems_semaphore_release> <== NOT EXECUTED
000229d4 <rtems_rfs_shell_usage>:
}
void
rtems_rfs_shell_usage (const char* arg)
{
229d4: e92d4010 push {r4, lr} <== NOT EXECUTED
printf ("%s: RFS debugger\n", arg);
229d8: e1a01000 mov r1, r0 <== NOT EXECUTED
}
void
rtems_rfs_shell_usage (const char* arg)
{
229dc: e1a04000 mov r4, r0 <== NOT EXECUTED
printf ("%s: RFS debugger\n", arg);
229e0: e59f0038 ldr r0, [pc, #56] ; 22a20 <rtems_rfs_shell_usage+0x4c><== NOT EXECUTED 229e4: eb0092df bl 47568 <printf> <== NOT EXECUTED
printf (" %s [-hl] <path> <command>\n", arg);
229e8: e1a01004 mov r1, r4 <== NOT EXECUTED 229ec: e59f0030 ldr r0, [pc, #48] ; 22a24 <rtems_rfs_shell_usage+0x50><== NOT EXECUTED 229f0: eb0092dc bl 47568 <printf> <== NOT EXECUTED
printf (" where:\n");
229f4: e59f002c ldr r0, [pc, #44] ; 22a28 <rtems_rfs_shell_usage+0x54><== NOT EXECUTED 229f8: eb00937f bl 477fc <puts> <== NOT EXECUTED
printf (" path: Path to the mounted RFS file system\n");
229fc: e59f0028 ldr r0, [pc, #40] ; 22a2c <rtems_rfs_shell_usage+0x58><== NOT EXECUTED 22a00: eb00937d bl 477fc <puts> <== NOT EXECUTED
printf (" command: A debugger command. See -l for a list plus help.\n");
22a04: e59f0024 ldr r0, [pc, #36] ; 22a30 <rtems_rfs_shell_usage+0x5c><== NOT EXECUTED 22a08: eb00937b bl 477fc <puts> <== NOT EXECUTED
printf (" -h: This help\n");
22a0c: e59f0020 ldr r0, [pc, #32] ; 22a34 <rtems_rfs_shell_usage+0x60><== NOT EXECUTED 22a10: eb009379 bl 477fc <puts> <== NOT EXECUTED
printf (" -l: The debugger command list.\n");
22a14: e59f001c ldr r0, [pc, #28] ; 22a38 <rtems_rfs_shell_usage+0x64><== NOT EXECUTED
}
22a18: e8bd4010 pop {r4, lr} <== NOT EXECUTED
printf (" %s [-hl] <path> <command>\n", arg);
printf (" where:\n");
printf (" path: Path to the mounted RFS file system\n");
printf (" command: A debugger command. See -l for a list plus help.\n");
printf (" -h: This help\n");
printf (" -l: The debugger command list.\n");
22a1c: ea009376 b 477fc <puts> <== NOT EXECUTED
0003d814 <rtems_rfs_symlink>:
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
3d814: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3d818: e24dd0a0 sub sp, sp, #160 ; 0xa0 <== NOT EXECUTED
3d81c: e59d50c4 ldr r5, [sp, #196] ; 0xc4 <== NOT EXECUTED
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
3d820: e5902008 ldr r2, [r0, #8] <== NOT EXECUTED 3d824: e1550002 cmp r5, r2 <== NOT EXECUTED
const char* link,
int link_length,
uid_t uid,
gid_t gid,
rtems_rfs_ino parent)
{
3d828: e1a04000 mov r4, r0 <== NOT EXECUTED 3d82c: e1a08001 mov r8, r1 <== NOT EXECUTED 3d830: e1a0a003 mov sl, r3 <== NOT EXECUTED 3d834: e1dd7cb8 ldrh r7, [sp, #200] ; 0xc8 <== NOT EXECUTED 3d838: e1dd6cbc ldrh r6, [sp, #204] ; 0xcc <== NOT EXECUTED
printf (" link:");
for (c = 0; c < link_length; c++)
printf ("%c", link[c]);
}
if (link_length >= rtems_rfs_fs_block_size (fs))
3d83c: 23a0905b movcs r9, #91 ; 0x5b <== NOT EXECUTED 3d840: 3a000002 bcc 3d850 <rtems_rfs_symlink+0x3c> <== NOT EXECUTED
rtems_rfs_inode_set_block_offset (&inode, link_length);
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
3d844: e1a00009 mov r0, r9 <== NOT EXECUTED
3d848: e28dd0a0 add sp, sp, #160 ; 0xa0 <== NOT EXECUTED
3d84c: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
}
if (link_length >= rtems_rfs_fs_block_size (fs))
return ENAMETOOLONG;
rc = rtems_rfs_inode_create (fs, parent, name, strlen (name),
3d850: e1a00001 mov r0, r1 <== NOT EXECUTED 3d854: eb0030e2 bl 49be4 <strlen> <== NOT EXECUTED 3d858: e3a0cca2 mov ip, #41472 ; 0xa200 <== NOT EXECUTED 3d85c: e24cc001 sub ip, ip, #1 <== NOT EXECUTED 3d860: e1a03000 mov r3, r0 <== NOT EXECUTED 3d864: e1a02008 mov r2, r8 <== NOT EXECUTED 3d868: e58dc000 str ip, [sp] <== NOT EXECUTED 3d86c: e59d10d0 ldr r1, [sp, #208] ; 0xd0 <== NOT EXECUTED 3d870: e28dc09c add ip, sp, #156 ; 0x9c <== NOT EXECUTED 3d874: e3a08001 mov r8, #1 <== NOT EXECUTED 3d878: e1a00004 mov r0, r4 <== NOT EXECUTED 3d87c: e58d7008 str r7, [sp, #8] <== NOT EXECUTED 3d880: e58d600c str r6, [sp, #12] <== NOT EXECUTED 3d884: e58dc010 str ip, [sp, #16] <== NOT EXECUTED 3d888: e58d8004 str r8, [sp, #4] <== NOT EXECUTED 3d88c: ebfffed8 bl 3d3f4 <rtems_rfs_inode_create> <== NOT EXECUTED
RTEMS_RFS_S_SYMLINK,
1, uid, gid, &ino);
if (rc > 0)
3d890: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3d894: caffffea bgt 3d844 <rtems_rfs_symlink+0x30> <== NOT EXECUTED
return rc;
rc = rtems_rfs_inode_open (fs, ino, &inode, true);
3d898: e28d6064 add r6, sp, #100 ; 0x64 <== NOT EXECUTED 3d89c: e1a00004 mov r0, r4 <== NOT EXECUTED 3d8a0: e59d109c ldr r1, [sp, #156] ; 0x9c <== NOT EXECUTED 3d8a4: e1a02006 mov r2, r6 <== NOT EXECUTED 3d8a8: e1a03008 mov r3, r8 <== NOT EXECUTED 3d8ac: ebfffe6c bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc > 0)
3d8b0: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3d8b4: caffffe2 bgt 3d844 <rtems_rfs_symlink+0x30> <== NOT EXECUTED
/* * If the link length is less than the length of data union in the inode * place the link into the data area else allocate a block and write the link * to that. */ if (link_length < RTEMS_RFS_INODE_DATA_NAME_SIZE)
3d8b8: e3550013 cmp r5, #19 <== NOT EXECUTED 3d8bc: 8a000021 bhi 3d948 <rtems_rfs_symlink+0x134> <== NOT EXECUTED
{
memset (inode.node->data.name, 0, RTEMS_RFS_INODE_DATA_NAME_SIZE);
3d8c0: e59d3070 ldr r3, [sp, #112] ; 0x70 <== NOT EXECUTED 3d8c4: e3a07000 mov r7, #0 <== NOT EXECUTED 3d8c8: e583702c str r7, [r3, #44] ; 0x2c <== NOT EXECUTED 3d8cc: e583701c str r7, [r3, #28] <== NOT EXECUTED 3d8d0: e5837020 str r7, [r3, #32] <== NOT EXECUTED 3d8d4: e5837024 str r7, [r3, #36] ; 0x24 <== NOT EXECUTED 3d8d8: e5837028 str r7, [r3, #40] ; 0x28 <== NOT EXECUTED
memcpy (inode.node->data.name, link, link_length);
3d8dc: e59d0070 ldr r0, [sp, #112] ; 0x70 <== NOT EXECUTED 3d8e0: e1a0100a mov r1, sl <== NOT EXECUTED 3d8e4: e280001c add r0, r0, #28 <== NOT EXECUTED 3d8e8: e1a02005 mov r2, r5 <== NOT EXECUTED 3d8ec: eb00226f bl 462b0 <memcpy> <== NOT EXECUTED
* @param block_count The block count.
*/
static inline void
rtems_rfs_inode_set_block_count (rtems_rfs_inode_handle* handle, uint32_t block_count)
{
rtems_rfs_write_u32 (&handle->node->block_count, block_count);
3d8f0: e59d3070 ldr r3, [sp, #112] ; 0x70 <== NOT EXECUTED 3d8f4: e5c3700c strb r7, [r3, #12] <== NOT EXECUTED 3d8f8: e59d3070 ldr r3, [sp, #112] ; 0x70 <== NOT EXECUTED 3d8fc: e5c3700d strb r7, [r3, #13] <== NOT EXECUTED 3d900: e59d3070 ldr r3, [sp, #112] ; 0x70 <== NOT EXECUTED 3d904: e5c3700e strb r7, [r3, #14] <== NOT EXECUTED 3d908: e59d3070 ldr r3, [sp, #112] ; 0x70 <== NOT EXECUTED 3d90c: e5c3700f strb r7, [r3, #15] <== NOT EXECUTED
*/
static inline void
rtems_rfs_inode_set_block_offset (rtems_rfs_inode_handle* handle,
uint16_t block_offset)
{
rtems_rfs_write_u16 (&handle->node->block_offset, block_offset);
3d910: e59d3070 ldr r3, [sp, #112] ; 0x70 <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
rtems_rfs_inode_set_block_offset (&inode, link_length);
3d914: e1a05805 lsl r5, r5, #16 <== NOT EXECUTED 3d918: e1a02c25 lsr r2, r5, #24 <== NOT EXECUTED 3d91c: e5c3200a strb r2, [r3, #10] <== NOT EXECUTED 3d920: e59d3070 ldr r3, [sp, #112] ; 0x70 <== NOT EXECUTED 3d924: e1a05825 lsr r5, r5, #16 <== NOT EXECUTED 3d928: e5c3500b strb r5, [r3, #11] <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
3d92c: e1a00004 mov r0, r4 <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3d930: e3a03001 mov r3, #1 <== NOT EXECUTED 3d934: e1a01006 mov r1, r6 <== NOT EXECUTED 3d938: e5cd3074 strb r3, [sp, #116] ; 0x74 <== NOT EXECUTED 3d93c: ebfffe24 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED 3d940: e1a09000 mov r9, r0 <== NOT EXECUTED
return rc;
3d944: eaffffbe b 3d844 <rtems_rfs_symlink+0x30> <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
uint8_t* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
3d948: e28d7014 add r7, sp, #20 <== NOT EXECUTED 3d94c: e1a00004 mov r0, r4 <== NOT EXECUTED 3d950: e1a01006 mov r1, r6 <== NOT EXECUTED 3d954: e1a02007 mov r2, r7 <== NOT EXECUTED 3d958: ebffef28 bl 39600 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
3d95c: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3d960: da000003 ble 3d974 <rtems_rfs_symlink+0x160> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
3d964: e1a00004 mov r0, r4 <== NOT EXECUTED 3d968: e1a01006 mov r1, r6 <== NOT EXECUTED 3d96c: ebfffe18 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
3d970: eaffffb3 b 3d844 <rtems_rfs_symlink+0x30> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_grow (fs, &map, 1, &block);
3d974: e1a02008 mov r2, r8 <== NOT EXECUTED 3d978: e1a00004 mov r0, r4 <== NOT EXECUTED 3d97c: e1a01007 mov r1, r7 <== NOT EXECUTED 3d980: e28d3098 add r3, sp, #152 ; 0x98 <== NOT EXECUTED 3d984: ebffedb1 bl 39050 <rtems_rfs_block_map_grow> <== NOT EXECUTED
if (rc > 0)
3d988: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3d98c: da000006 ble 3d9ac <rtems_rfs_symlink+0x198> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
3d990: e1a01007 mov r1, r7 <== NOT EXECUTED 3d994: e1a00004 mov r0, r4 <== NOT EXECUTED 3d998: ebffeea5 bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
3d99c: e1a00004 mov r0, r4 <== NOT EXECUTED 3d9a0: e1a01006 mov r1, r6 <== NOT EXECUTED 3d9a4: ebfffe0a bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
3d9a8: eaffffa5 b 3d844 <rtems_rfs_symlink+0x30> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
3d9ac: e3a08000 mov r8, #0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
3d9b0: e28db08c add fp, sp, #140 ; 0x8c <== NOT EXECUTED 3d9b4: e1a00004 mov r0, r4 <== NOT EXECUTED 3d9b8: e1a0100b mov r1, fp <== NOT EXECUTED 3d9bc: e59d2098 ldr r2, [sp, #152] ; 0x98 <== NOT EXECUTED 3d9c0: e1a03008 mov r3, r8 <== NOT EXECUTED 3d9c4: e5cd808c strb r8, [sp, #140] ; 0x8c <== NOT EXECUTED
handle->bnum = 0;
3d9c8: e58d8090 str r8, [sp, #144] ; 0x90 <== NOT EXECUTED
handle->buffer = NULL;
3d9cc: e58d8094 str r8, [sp, #148] ; 0x94 <== NOT EXECUTED 3d9d0: ebfff01f bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
3d9d4: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3d9d8: da000003 ble 3d9ec <rtems_rfs_symlink+0x1d8> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
3d9dc: e1a01007 mov r1, r7 <== NOT EXECUTED 3d9e0: e1a00004 mov r0, r4 <== NOT EXECUTED 3d9e4: ebffee92 bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED 3d9e8: eaffffdd b 3d964 <rtems_rfs_symlink+0x150> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
3d9ec: e59d3094 ldr r3, [sp, #148] ; 0x94 <== NOT EXECUTED 3d9f0: e5939020 ldr r9, [r3, #32] <== NOT EXECUTED
memset (data, 0xff, rtems_rfs_fs_block_size (fs));
3d9f4: e3a010ff mov r1, #255 ; 0xff <== NOT EXECUTED 3d9f8: e1a00009 mov r0, r9 <== NOT EXECUTED 3d9fc: e5942008 ldr r2, [r4, #8] <== NOT EXECUTED 3da00: eb0022b1 bl 464cc <memset> <== NOT EXECUTED
memcpy (data, link, link_length);
3da04: e1a02005 mov r2, r5 <== NOT EXECUTED 3da08: e1a00009 mov r0, r9 <== NOT EXECUTED 3da0c: e1a0100a mov r1, sl <== NOT EXECUTED 3da10: eb002226 bl 462b0 <memcpy> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3da14: e1a0100b mov r1, fp <== NOT EXECUTED 3da18: e1a00004 mov r0, r4 <== NOT EXECUTED 3da1c: ebffefc2 bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_close (fs, &map);
3da20: e1a01007 mov r1, r7 <== NOT EXECUTED 3da24: e1a00004 mov r0, r4 <== NOT EXECUTED
handle->dirty = false; handle->bnum = 0; handle->buffer = NULL;
3da28: e58d8094 str r8, [sp, #148] ; 0x94 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3da2c: e5cd808c strb r8, [sp, #140] ; 0x8c <== NOT EXECUTED
handle->bnum = 0;
3da30: e58d8090 str r8, [sp, #144] ; 0x90 <== NOT EXECUTED 3da34: ebffee7e bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
3da38: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3da3c: daffffb3 ble 3d910 <rtems_rfs_symlink+0xfc> <== NOT EXECUTED 3da40: eaffffc7 b 3d964 <rtems_rfs_symlink+0x150> <== NOT EXECUTED
0003d658 <rtems_rfs_symlink_read>:
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
rtems_rfs_ino link,
char* path,
size_t size,
size_t* length)
{
3d658: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3d65c: e24dd08c sub sp, sp, #140 ; 0x8c <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
3d660: e28d4054 add r4, sp, #84 ; 0x54 <== NOT EXECUTED
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
rtems_rfs_ino link,
char* path,
size_t size,
size_t* length)
{
3d664: e1a07002 mov r7, r2 <== NOT EXECUTED 3d668: e1a06003 mov r6, r3 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
3d66c: e1a02004 mov r2, r4 <== NOT EXECUTED 3d670: e3a03001 mov r3, #1 <== NOT EXECUTED
rtems_rfs_symlink_read (rtems_rfs_file_system* fs,
rtems_rfs_ino link,
char* path,
size_t size,
size_t* length)
{
3d674: e1a05000 mov r5, r0 <== NOT EXECUTED 3d678: e59d80b0 ldr r8, [sp, #176] ; 0xb0 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_SYMLINK_READ))
printf ("rtems-rfs: symlink-read: link:%" PRIu32 "\n", link);
rc = rtems_rfs_inode_open (fs, link, &inode, true);
3d67c: ebfffef8 bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
3d680: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3d684: 1a000009 bne 3d6b0 <rtems_rfs_symlink_read+0x58> <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
3d688: e59d1060 ldr r1, [sp, #96] ; 0x60 <== NOT EXECUTED
return rc;
if (!RTEMS_RFS_S_ISLNK (rtems_rfs_inode_get_mode (&inode)))
3d68c: e5d13002 ldrb r3, [r1, #2] <== NOT EXECUTED 3d690: e1a03403 lsl r3, r3, #8 <== NOT EXECUTED 3d694: e2033a0f and r3, r3, #61440 ; 0xf000 <== NOT EXECUTED 3d698: e3530a0a cmp r3, #40960 ; 0xa000 <== NOT EXECUTED 3d69c: 0a000006 beq 3d6bc <rtems_rfs_symlink_read+0x64> <== NOT EXECUTED
*length = rtems_rfs_inode_get_block_offset (&inode);
if (size < *length)
{
rtems_rfs_inode_close (fs, &inode);
3d6a0: e1a00005 mov r0, r5 <== NOT EXECUTED 3d6a4: e1a01004 mov r1, r4 <== NOT EXECUTED 3d6a8: ebfffec9 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED 3d6ac: e3a09016 mov r9, #22 <== NOT EXECUTED
path[*length] = '\0';
rc = rtems_rfs_inode_close (fs, &inode);
return rc;
}
3d6b0: e1a00009 mov r0, r9 <== NOT EXECUTED
3d6b4: e28dd08c add sp, sp, #140 ; 0x8c <== NOT EXECUTED
3d6b8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
3d6bc: e5d1200a ldrb r2, [r1, #10] <== NOT EXECUTED 3d6c0: e5d1300b ldrb r3, [r1, #11] <== NOT EXECUTED 3d6c4: e1832402 orr r2, r3, r2, lsl #8 <== NOT EXECUTED
if (size < *length)
3d6c8: e1520006 cmp r2, r6 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
*length = rtems_rfs_inode_get_block_offset (&inode);
3d6cc: e5882000 str r2, [r8] <== NOT EXECUTED
if (size < *length)
3d6d0: 8afffff2 bhi 3d6a0 <rtems_rfs_symlink_read+0x48> <== NOT EXECUTED
* @return uint32_t The block count.
*/
static inline uint32_t
rtems_rfs_inode_get_block_count (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u32 (&handle->node->block_count);
3d6d4: e281300c add r3, r1, #12 <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return EINVAL;
}
if (rtems_rfs_inode_get_block_count (&inode) == 0)
3d6d8: e5d30003 ldrb r0, [r3, #3] <== NOT EXECUTED 3d6dc: e5d1c00c ldrb ip, [r1, #12] <== NOT EXECUTED 3d6e0: e5d3e001 ldrb lr, [r3, #1] <== NOT EXECUTED 3d6e4: e180cc0c orr ip, r0, ip, lsl #24 <== NOT EXECUTED 3d6e8: e5d30002 ldrb r0, [r3, #2] <== NOT EXECUTED 3d6ec: e18c380e orr r3, ip, lr, lsl #16 <== NOT EXECUTED 3d6f0: e1930400 orrs r0, r3, r0, lsl #8 <== NOT EXECUTED 3d6f4: 1a00000a bne 3d724 <rtems_rfs_symlink_read+0xcc> <== NOT EXECUTED
{
memcpy (path, inode.node->data.name, *length);
3d6f8: e281101c add r1, r1, #28 <== NOT EXECUTED 3d6fc: e1a00007 mov r0, r7 <== NOT EXECUTED 3d700: eb0022ea bl 462b0 <memcpy> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
}
path[*length] = '\0';
3d704: e5983000 ldr r3, [r8] <== NOT EXECUTED 3d708: e3a02000 mov r2, #0 <== NOT EXECUTED 3d70c: e7c72003 strb r2, [r7, r3] <== NOT EXECUTED
rc = rtems_rfs_inode_close (fs, &inode);
3d710: e1a00005 mov r0, r5 <== NOT EXECUTED 3d714: e1a01004 mov r1, r4 <== NOT EXECUTED 3d718: ebfffead bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED 3d71c: e1a09000 mov r9, r0 <== NOT EXECUTED
return rc;
3d720: eaffffe2 b 3d6b0 <rtems_rfs_symlink_read+0x58> <== NOT EXECUTED
rtems_rfs_block_map map;
rtems_rfs_block_no block;
rtems_rfs_buffer_handle buffer;
char* data;
rc = rtems_rfs_block_map_open (fs, &inode, &map);
3d724: e28d6004 add r6, sp, #4 <== NOT EXECUTED 3d728: e1a00005 mov r0, r5 <== NOT EXECUTED 3d72c: e1a01004 mov r1, r4 <== NOT EXECUTED 3d730: e1a02006 mov r2, r6 <== NOT EXECUTED 3d734: ebffefb1 bl 39600 <rtems_rfs_block_map_open> <== NOT EXECUTED
if (rc > 0)
3d738: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3d73c: da000003 ble 3d750 <rtems_rfs_symlink_read+0xf8> <== NOT EXECUTED
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
if (rc > 0)
{
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
3d740: e1a00005 mov r0, r5 <== NOT EXECUTED 3d744: e1a01004 mov r1, r4 <== NOT EXECUTED 3d748: ebfffea1 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
3d74c: eaffffd7 b 3d6b0 <rtems_rfs_symlink_read+0x58> <== NOT EXECUTED
{
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_seek (fs, &map, 0, &block);
3d750: e28dc088 add ip, sp, #136 ; 0x88 <== NOT EXECUTED 3d754: e1a00005 mov r0, r5 <== NOT EXECUTED 3d758: e1a01006 mov r1, r6 <== NOT EXECUTED 3d75c: e3a02000 mov r2, #0 <== NOT EXECUTED 3d760: e3a03000 mov r3, #0 <== NOT EXECUTED 3d764: e58dc000 str ip, [sp] <== NOT EXECUTED 3d768: ebffecea bl 38b18 <rtems_rfs_block_map_seek> <== NOT EXECUTED
if (rc > 0)
3d76c: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3d770: da000006 ble 3d790 <rtems_rfs_symlink_read+0x138> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
3d774: e1a01006 mov r1, r6 <== NOT EXECUTED 3d778: e1a00005 mov r0, r5 <== NOT EXECUTED 3d77c: ebffef2c bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
3d780: e1a00005 mov r0, r5 <== NOT EXECUTED 3d784: e1a01004 mov r1, r4 <== NOT EXECUTED 3d788: ebfffe91 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
3d78c: eaffffc7 b 3d6b0 <rtems_rfs_symlink_read+0x58> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_open (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
handle->dirty = false;
3d790: e3a0a000 mov sl, #0 <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_buffer_handle_request (fs, &buffer, block, false);
3d794: e28db07c add fp, sp, #124 ; 0x7c <== NOT EXECUTED 3d798: e1a00005 mov r0, r5 <== NOT EXECUTED 3d79c: e1a0100b mov r1, fp <== NOT EXECUTED 3d7a0: e59d2088 ldr r2, [sp, #136] ; 0x88 <== NOT EXECUTED 3d7a4: e1a0300a mov r3, sl <== NOT EXECUTED 3d7a8: e5cda07c strb sl, [sp, #124] ; 0x7c <== NOT EXECUTED
handle->bnum = 0;
3d7ac: e58da080 str sl, [sp, #128] ; 0x80 <== NOT EXECUTED
handle->buffer = NULL;
3d7b0: e58da084 str sl, [sp, #132] ; 0x84 <== NOT EXECUTED 3d7b4: ebfff0a6 bl 39a54 <rtems_rfs_buffer_handle_request> <== NOT EXECUTED
if (rc > 0)
3d7b8: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3d7bc: da000003 ble 3d7d0 <rtems_rfs_symlink_read+0x178> <== NOT EXECUTED
{
rtems_rfs_block_map_close (fs, &map);
3d7c0: e1a01006 mov r1, r6 <== NOT EXECUTED 3d7c4: e1a00005 mov r0, r5 <== NOT EXECUTED 3d7c8: ebffef19 bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED 3d7cc: eaffffdb b 3d740 <rtems_rfs_symlink_read+0xe8> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &inode);
return rc;
}
data = rtems_rfs_buffer_data (&buffer);
memcpy (path, data, *length);
3d7d0: e59d3084 ldr r3, [sp, #132] ; 0x84 <== NOT EXECUTED 3d7d4: e5982000 ldr r2, [r8] <== NOT EXECUTED 3d7d8: e5931020 ldr r1, [r3, #32] <== NOT EXECUTED 3d7dc: e1a00007 mov r0, r7 <== NOT EXECUTED 3d7e0: eb0022b2 bl 462b0 <memcpy> <== NOT EXECUTED
*/
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
3d7e4: e1a0100b mov r1, fp <== NOT EXECUTED 3d7e8: e1a00005 mov r0, r5 <== NOT EXECUTED 3d7ec: ebfff04e bl 3992c <rtems_rfs_buffer_handle_release> <== NOT EXECUTED
rtems_rfs_block_map_close (fs, &map);
rtems_rfs_inode_close (fs, &inode);
return rc;
}
rc = rtems_rfs_block_map_close (fs, &map);
3d7f0: e1a01006 mov r1, r6 <== NOT EXECUTED 3d7f4: e1a00005 mov r0, r5 <== NOT EXECUTED
handle->dirty = false; handle->bnum = 0; handle->buffer = NULL;
3d7f8: e58da084 str sl, [sp, #132] ; 0x84 <== NOT EXECUTED
static inline int
rtems_rfs_buffer_handle_close (rtems_rfs_file_system* fs,
rtems_rfs_buffer_handle* handle)
{
rtems_rfs_buffer_handle_release (fs, handle);
handle->dirty = false;
3d7fc: e5cda07c strb sl, [sp, #124] ; 0x7c <== NOT EXECUTED
handle->bnum = 0;
3d800: e58da080 str sl, [sp, #128] ; 0x80 <== NOT EXECUTED 3d804: ebffef0a bl 39434 <rtems_rfs_block_map_close> <== NOT EXECUTED
if (rc > 0)
3d808: e2509000 subs r9, r0, #0 <== NOT EXECUTED 3d80c: daffffbc ble 3d704 <rtems_rfs_symlink_read+0xac> <== NOT EXECUTED 3d810: eaffffca b 3d740 <rtems_rfs_symlink_read+0xe8> <== NOT EXECUTED
0003da44 <rtems_rfs_unlink>:
rtems_rfs_unlink (rtems_rfs_file_system* fs,
rtems_rfs_ino parent,
rtems_rfs_ino target,
uint32_t doff,
rtems_rfs_unlink_dir dir_mode)
{
3da44: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
3da48: e24dd050 sub sp, sp, #80 ; 0x50 <== NOT EXECUTED
3da4c: e1a06002 mov r6, r2 <== NOT EXECUTED
3da50: e1a08001 mov r8, r1 <== NOT EXECUTED
3da54: e1a0a003 mov sl, r3 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
3da58: e1a01002 mov r1, r2 <== NOT EXECUTED 3da5c: e3a03001 mov r3, #1 <== NOT EXECUTED 3da60: e1a0200d mov r2, sp <== NOT EXECUTED
rtems_rfs_unlink (rtems_rfs_file_system* fs,
rtems_rfs_ino parent,
rtems_rfs_ino target,
uint32_t doff,
rtems_rfs_unlink_dir dir_mode)
{
3da64: e1a05000 mov r5, r0 <== NOT EXECUTED 3da68: e59d7074 ldr r7, [sp, #116] ; 0x74 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
3da6c: ebfffdfc bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
3da70: e250b000 subs fp, r0, #0 <== NOT EXECUTED
int rc;
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: parent(%" PRIu32 ") -X-> (%" PRIu32 ")\n", parent, target);
rc = rtems_rfs_inode_open (fs, target, &target_inode, true);
3da74: e1a0400d mov r4, sp <== NOT EXECUTED
if (rc)
3da78: 1a00000e bne 3dab8 <rtems_rfs_unlink+0x74> <== NOT EXECUTED
* @return uint16_t The mode.
*/
static inline uint16_t
rtems_rfs_inode_get_mode (rtems_rfs_inode_handle* handle)
{
return rtems_rfs_read_u16 (&handle->node->mode);
3da7c: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED
/*
* If a directory process the unlink mode.
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
3da80: e5d39002 ldrb r9, [r3, #2] <== NOT EXECUTED 3da84: e1a09409 lsl r9, r9, #8 <== NOT EXECUTED 3da88: e2099a0f and r9, r9, #61440 ; 0xf000 <== NOT EXECUTED 3da8c: e3590901 cmp r9, #16384 ; 0x4000 <== NOT EXECUTED 3da90: 13a09000 movne r9, #0 <== NOT EXECUTED 3da94: 03a09001 moveq r9, #1 <== NOT EXECUTED
if (dir)
3da98: e3590000 cmp r9, #0 <== NOT EXECUTED 3da9c: 0a00000a beq 3dacc <rtems_rfs_unlink+0x88> <== NOT EXECUTED
{
switch (dir_mode)
3daa0: e3570000 cmp r7, #0 <== NOT EXECUTED 3daa4: 1a000006 bne 3dac4 <rtems_rfs_unlink+0x80> <== NOT EXECUTED
{
case rtems_rfs_unlink_dir_denied:
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
3daa8: e1a00005 mov r0, r5 <== NOT EXECUTED 3daac: e1a0100d mov r1, sp <== NOT EXECUTED 3dab0: ebfffdc7 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED 3dab4: e3a0b015 mov fp, #21 <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
}
3dab8: e1a0000b mov r0, fp <== NOT EXECUTED
3dabc: e28dd050 add sp, sp, #80 ; 0x50 <== NOT EXECUTED
3dac0: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
*/
dir = RTEMS_RFS_S_ISDIR (rtems_rfs_inode_get_mode (&target_inode));
if (dir)
{
switch (dir_mode)
3dac4: e3570001 cmp r7, #1 <== NOT EXECUTED 3dac8: 0a000037 beq 3dbac <rtems_rfs_unlink+0x168> <== NOT EXECUTED
default:
break;
}
}
rc = rtems_rfs_inode_open (fs, parent, &parent_inode, true);
3dacc: e28d7028 add r7, sp, #40 ; 0x28 <== NOT EXECUTED 3dad0: e1a01008 mov r1, r8 <== NOT EXECUTED 3dad4: e1a00005 mov r0, r5 <== NOT EXECUTED 3dad8: e1a02007 mov r2, r7 <== NOT EXECUTED 3dadc: e3a03001 mov r3, #1 <== NOT EXECUTED 3dae0: ebfffddf bl 3d264 <rtems_rfs_inode_open> <== NOT EXECUTED
if (rc)
3dae4: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3dae8: 1a00002b bne 3db9c <rtems_rfs_unlink+0x158> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_dir_del_entry (fs, &parent_inode, target, doff);
3daec: e1a02006 mov r2, r6 <== NOT EXECUTED 3daf0: e1a0300a mov r3, sl <== NOT EXECUTED 3daf4: e1a00005 mov r0, r5 <== NOT EXECUTED 3daf8: e1a01007 mov r1, r7 <== NOT EXECUTED 3dafc: ebfff120 bl 39f84 <rtems_rfs_dir_del_entry> <== NOT EXECUTED
if (rc > 0)
3db00: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3db04: ca000018 bgt 3db6c <rtems_rfs_unlink+0x128> <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
3db08: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 3db0c: e5d20000 ldrb r0, [r2] <== NOT EXECUTED 3db10: e5d21001 ldrb r1, [r2, #1] <== NOT EXECUTED
if (links == 0xffff)
3db14: e3a03801 mov r3, #65536 ; 0x10000 <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
3db18: e1811400 orr r1, r1, r0, lsl #8 <== NOT EXECUTED
if (links == 0xffff)
3db1c: e2433001 sub r3, r3, #1 <== NOT EXECUTED 3db20: e1510003 cmp r1, r3 <== NOT EXECUTED 3db24: 0a00002b beq 3dbd8 <rtems_rfs_unlink+0x194> <== NOT EXECUTED
links = rtems_rfs_inode_get_links (&target_inode);
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: unlink: target:%" PRIu32 " links:%u\n", target, links);
if (links > 1)
3db28: e3510001 cmp r1, #1 <== NOT EXECUTED 3db2c: 9a000029 bls 3dbd8 <rtems_rfs_unlink+0x194> <== NOT EXECUTED
{
links--;
3db30: e2411001 sub r1, r1, #1 <== NOT EXECUTED 3db34: e1a01801 lsl r1, r1, #16 <== NOT EXECUTED
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
3db38: e1a03c21 lsr r3, r1, #24 <== NOT EXECUTED 3db3c: e5c23000 strb r3, [r2] <== NOT EXECUTED 3db40: e59d300c ldr r3, [sp, #12] <== NOT EXECUTED 3db44: e1a01821 lsr r1, r1, #16 <== NOT EXECUTED 3db48: e5c31001 strb r1, [r3, #1] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3db4c: e3a03001 mov r3, #1 <== NOT EXECUTED 3db50: e5cd3010 strb r3, [sp, #16] <== NOT EXECUTED
links--;
rtems_rfs_inode_set_links (&parent_inode, links);
}
}
rc = rtems_rfs_inode_time_stamp_now (&parent_inode, true, true);
3db54: e3a01001 mov r1, #1 <== NOT EXECUTED 3db58: e1a00007 mov r0, r7 <== NOT EXECUTED 3db5c: e1a02001 mov r2, r1 <== NOT EXECUTED 3db60: ebfffcea bl 3cf10 <rtems_rfs_inode_time_stamp_now> <== NOT EXECUTED
if (rc > 0)
3db64: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3db68: da000006 ble 3db88 <rtems_rfs_unlink+0x144> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: inode-time-stamp failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &parent_inode);
3db6c: e1a01007 mov r1, r7 <== NOT EXECUTED 3db70: e1a00005 mov r0, r5 <== NOT EXECUTED 3db74: ebfffd96 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &target_inode);
3db78: e1a00005 mov r0, r5 <== NOT EXECUTED 3db7c: e1a0100d mov r1, sp <== NOT EXECUTED 3db80: ebfffd93 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
3db84: eaffffcb b 3dab8 <rtems_rfs_unlink+0x74> <== NOT EXECUTED
}
rc = rtems_rfs_inode_close (fs, &parent_inode);
3db88: e1a01007 mov r1, r7 <== NOT EXECUTED 3db8c: e1a00005 mov r0, r5 <== NOT EXECUTED 3db90: ebfffd8f bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
if (rc > 0)
3db94: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3db98: da000009 ble 3dbc4 <rtems_rfs_unlink+0x180> <== NOT EXECUTED
{
if (rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: parent inode-close failed: %d: %s\n",
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
3db9c: e1a00005 mov r0, r5 <== NOT EXECUTED 3dba0: e1a0100d mov r1, sp <== NOT EXECUTED 3dba4: ebfffd8a bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED
return rc;
3dba8: eaffffc2 b 3dab8 <rtems_rfs_unlink+0x74> <== NOT EXECUTED
printf ("rtems-rfs: link is a directory\n");
rtems_rfs_inode_close (fs, &target_inode);
return EISDIR;
case rtems_rfs_unlink_dir_if_empty:
rc = rtems_rfs_dir_empty (fs, &target_inode);
3dbac: e1a00005 mov r0, r5 <== NOT EXECUTED 3dbb0: e1a0100d mov r1, sp <== NOT EXECUTED 3dbb4: ebfff31f bl 3a838 <rtems_rfs_dir_empty> <== NOT EXECUTED
if (rc > 0)
3dbb8: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3dbbc: daffffc2 ble 3dacc <rtems_rfs_unlink+0x88> <== NOT EXECUTED 3dbc0: eafffff5 b 3db9c <rtems_rfs_unlink+0x158> <== NOT EXECUTED
rc, strerror (rc));
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
rc = rtems_rfs_inode_close (fs, &target_inode);
3dbc4: e1a00005 mov r0, r5 <== NOT EXECUTED 3dbc8: e1a0100d mov r1, sp <== NOT EXECUTED 3dbcc: ebfffd80 bl 3d1d4 <rtems_rfs_inode_close> <== NOT EXECUTED 3dbd0: e1a0b000 mov fp, r0 <== NOT EXECUTED
if ((rc > 0) && rtems_rfs_trace (RTEMS_RFS_TRACE_UNLINK))
printf ("rtems-rfs: link: target inode-close failed: %d: %s\n",
rc, strerror (rc));
return rc;
3dbd4: eaffffb7 b 3dab8 <rtems_rfs_unlink+0x74> <== NOT EXECUTED
else
{
/*
* Erasing the inode releases all blocks attached to it.
*/
rc = rtems_rfs_inode_delete (fs, &target_inode);
3dbd8: e1a00005 mov r0, r5 <== NOT EXECUTED 3dbdc: e1a0100d mov r1, sp <== NOT EXECUTED 3dbe0: ebfffdd1 bl 3d32c <rtems_rfs_inode_delete> <== NOT EXECUTED
if (rc > 0)
3dbe4: e250b000 subs fp, r0, #0 <== NOT EXECUTED 3dbe8: caffffdf bgt 3db6c <rtems_rfs_unlink+0x128> <== NOT EXECUTED
rtems_rfs_inode_close (fs, &parent_inode);
rtems_rfs_inode_close (fs, &target_inode);
return rc;
}
if (dir)
3dbec: e3590000 cmp r9, #0 <== NOT EXECUTED 3dbf0: 0affffd7 beq 3db54 <rtems_rfs_unlink+0x110> <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
3dbf4: e59d3034 ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED 3dbf8: e5d30000 ldrb r0, [r3] <== NOT EXECUTED 3dbfc: e5d31001 ldrb r1, [r3, #1] <== NOT EXECUTED
if (links == 0xffff)
3dc00: e3a02801 mov r2, #65536 ; 0x10000 <== NOT EXECUTED
*/
static inline uint16_t
rtems_rfs_inode_get_links (rtems_rfs_inode_handle* handle)
{
uint16_t links;
links = rtems_rfs_read_u16 (&handle->node->links);
3dc04: e1811400 orr r1, r1, r0, lsl #8 <== NOT EXECUTED
if (links == 0xffff)
3dc08: e2422001 sub r2, r2, #1 <== NOT EXECUTED 3dc0c: e1510002 cmp r1, r2 <== NOT EXECUTED 3dc10: 03a01000 moveq r1, #0 <== NOT EXECUTED 3dc14: 01a02001 moveq r2, r1 <== NOT EXECUTED 3dc18: 0a000007 beq 3dc3c <rtems_rfs_unlink+0x1f8> <== NOT EXECUTED
{
links = rtems_rfs_inode_get_links (&parent_inode);
if (links > 1)
3dc1c: e3510001 cmp r1, #1 <== NOT EXECUTED
links--;
3dc20: 82412001 subhi r2, r1, #1 <== NOT EXECUTED 3dc24: 81a02802 lslhi r2, r2, #16 <== NOT EXECUTED 3dc28: 81a01822 lsrhi r1, r2, #16 <== NOT EXECUTED
}
if (dir)
{
links = rtems_rfs_inode_get_links (&parent_inode);
if (links > 1)
3dc2c: 920110ff andls r1, r1, #255 ; 0xff <== NOT EXECUTED 3dc30: 93a02000 movls r2, #0 <== NOT EXECUTED
links--;
3dc34: 81a02c22 lsrhi r2, r2, #24 <== NOT EXECUTED 3dc38: 820110ff andhi r1, r1, #255 ; 0xff <== NOT EXECUTED
* @prarm links The links.
*/
static inline void
rtems_rfs_inode_set_links (rtems_rfs_inode_handle* handle, uint16_t links)
{
rtems_rfs_write_u16 (&handle->node->links, links);
3dc3c: e5c32000 strb r2, [r3] <== NOT EXECUTED 3dc40: e59d3034 ldr r3, [sp, #52] ; 0x34 <== NOT EXECUTED 3dc44: e5c31001 strb r1, [r3, #1] <== NOT EXECUTED
rtems_rfs_buffer_mark_dirty (&handle->buffer);
3dc48: e3a03001 mov r3, #1 <== NOT EXECUTED 3dc4c: e5cd3038 strb r3, [sp, #56] ; 0x38 <== NOT EXECUTED 3dc50: eaffffbf b 3db54 <rtems_rfs_unlink+0x110> <== NOT EXECUTED
00023a90 <rtems_shell_debugrfs>:
printf (" -l: The debugger command list.\n");
}
int
rtems_shell_debugrfs (int argc, char *argv[])
{
23a90: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
"Display a block as a table for directory entrie, dir <bno>" },
{ "group", rtems_rfs_shell_group,
"Display the group data of a file system, group, group <group>, group <start> <end>" },
{ "inode", rtems_rfs_shell_inode,
"Display an inode, inode <ino>, inode> <ino>..<ino>" }
};
23a94: e59fe234 ldr lr, [pc, #564] ; 23cd0 <rtems_shell_debugrfs+0x240><== NOT EXECUTED
printf (" -l: The debugger command list.\n");
}
int
rtems_shell_debugrfs (int argc, char *argv[])
{
23a98: e24dd08c sub sp, sp, #140 ; 0x8c <== NOT EXECUTED 23a9c: e1a06000 mov r6, r0 <== NOT EXECUTED 23aa0: e1a05001 mov r5, r1 <== NOT EXECUTED
"Display a block as a table for directory entrie, dir <bno>" },
{ "group", rtems_rfs_shell_group,
"Display the group data of a file system, group, group <group>, group <start> <end>" },
{ "inode", rtems_rfs_shell_inode,
"Display an inode, inode <ino>, inode> <ino>..<ino>" }
};
23aa4: e28d4004 add r4, sp, #4 <== NOT EXECUTED
23aa8: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
23aac: e1a0c004 mov ip, r4 <== NOT EXECUTED
23ab0: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
23ab4: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
23ab8: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
23abc: e8be000f ldm lr!, {r0, r1, r2, r3} <== NOT EXECUTED
23ac0: e8ac000f stmia ip!, {r0, r1, r2, r3} <== NOT EXECUTED
23ac4: e89e0007 ldm lr, {r0, r1, r2} <== NOT EXECUTED
int arg;
int t;
for (arg = 1; arg < argc; arg++)
23ac8: e3560001 cmp r6, #1 <== NOT EXECUTED
"Display a block as a table for directory entrie, dir <bno>" },
{ "group", rtems_rfs_shell_group,
"Display the group data of a file system, group, group <group>, group <start> <end>" },
{ "inode", rtems_rfs_shell_inode,
"Display an inode, inode <ino>, inode> <ino>..<ino>" }
};
23acc: e88c0007 stm ip, {r0, r1, r2} <== NOT EXECUTED
int arg;
int t;
for (arg = 1; arg < argc; arg++)
23ad0: da000038 ble 23bb8 <rtems_shell_debugrfs+0x128> <== NOT EXECUTED
{
if (argv[arg][0] != '-')
23ad4: e5958004 ldr r8, [r5, #4] <== NOT EXECUTED 23ad8: e5d83000 ldrb r3, [r8] <== NOT EXECUTED 23adc: e353002d cmp r3, #45 ; 0x2d <== NOT EXECUTED 23ae0: 0a000039 beq 23bcc <rtems_shell_debugrfs+0x13c> <== NOT EXECUTED
printf ("error: unknown option: %s\n", argv[arg]);
return 1;
}
}
if ((argc - arg) < 2)
23ae4: e3560002 cmp r6, #2 <== NOT EXECUTED 23ae8: 0a000032 beq 23bb8 <rtems_shell_debugrfs+0x128> <== NOT EXECUTED
rtems_rfs_get_fs (const char* path, rtems_rfs_file_system** fs)
{
struct statvfs sb;
int rc;
rc = statvfs (path, &sb);
23aec: e1a00008 mov r0, r8 <== NOT EXECUTED 23af0: e28d1040 add r1, sp, #64 ; 0x40 <== NOT EXECUTED 23af4: eb001baa bl 2a9a4 <statvfs> <== NOT EXECUTED
if (rc < 0)
23af8: e3500000 cmp r0, #0 <== NOT EXECUTED 23afc: ba000067 blt 23ca0 <rtems_shell_debugrfs+0x210> <== NOT EXECUTED
printf ("error: cannot statvfs path: %s: (%d) %s\n",
path, errno, strerror (errno));
return -1;
}
if (sb.f_fsid != RTEMS_RFS_SB_MAGIC)
23b00: e3a0334a mov r3, #671088641 ; 0x28000001 <== NOT EXECUTED 23b04: e59d206c ldr r2, [sp, #108] ; 0x6c <== NOT EXECUTED 23b08: e2833a92 add r3, r3, #598016 ; 0x92000 <== NOT EXECUTED 23b0c: e1520003 cmp r2, r3 <== NOT EXECUTED 23b10: 1a00005d bne 23c8c <rtems_shell_debugrfs+0x1fc> <== NOT EXECUTED
* Now find the path location on the file system. This will give the file
* system data.
*/
{
rtems_filesystem_location_info_t pathloc;
rc = rtems_filesystem_evaluate_path (path, strlen (path), 0, &pathloc, true);
23b14: e1a00008 mov r0, r8 <== NOT EXECUTED 23b18: eb009831 bl 49be4 <strlen> <== NOT EXECUTED 23b1c: e28d7078 add r7, sp, #120 ; 0x78 <== NOT EXECUTED 23b20: e1a01000 mov r1, r0 <== NOT EXECUTED 23b24: e3a02000 mov r2, #0 <== NOT EXECUTED 23b28: e1a00008 mov r0, r8 <== NOT EXECUTED 23b2c: e1a03007 mov r3, r7 <== NOT EXECUTED 23b30: e3a0c001 mov ip, #1 <== NOT EXECUTED 23b34: e58dc000 str ip, [sp] <== NOT EXECUTED 23b38: ebff906a bl 7ce8 <rtems_filesystem_evaluate_path> <== NOT EXECUTED
*fs = rtems_rfs_rtems_pathloc_dev (&pathloc);
rtems_filesystem_freenode (&pathloc);
23b3c: e59d3084 ldr r3, [sp, #132] ; 0x84 <== NOT EXECUTED
* system data.
*/
{
rtems_filesystem_location_info_t pathloc;
rc = rtems_filesystem_evaluate_path (path, strlen (path), 0, &pathloc, true);
*fs = rtems_rfs_rtems_pathloc_dev (&pathloc);
23b40: e59d2088 ldr r2, [sp, #136] ; 0x88 <== NOT EXECUTED
rtems_filesystem_freenode (&pathloc);
23b44: e3530000 cmp r3, #0 <== NOT EXECUTED
* Now find the path location on the file system. This will give the file
* system data.
*/
{
rtems_filesystem_location_info_t pathloc;
rc = rtems_filesystem_evaluate_path (path, strlen (path), 0, &pathloc, true);
23b48: e1a08000 mov r8, r0 <== NOT EXECUTED
*fs = rtems_rfs_rtems_pathloc_dev (&pathloc);
23b4c: e592a034 ldr sl, [r2, #52] ; 0x34 <== NOT EXECUTED
rtems_filesystem_freenode (&pathloc);
23b50: 0a000004 beq 23b68 <rtems_shell_debugrfs+0xd8> <== NOT EXECUTED 23b54: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 23b58: e3530000 cmp r3, #0 <== NOT EXECUTED 23b5c: 11a00007 movne r0, r7 <== NOT EXECUTED 23b60: 11a0e00f movne lr, pc <== NOT EXECUTED 23b64: 112fff13 bxne r3 <== NOT EXECUTED
if ((argc - arg) < 2)
printf ("error: you need at least a path and command, try %s -h\n", argv[0]);
else
{
rtems_rfs_file_system* fs;
if (rtems_rfs_get_fs (argv[arg], &fs) == 0)
23b68: e3580000 cmp r8, #0 <== NOT EXECUTED 23b6c: 1a00000e bne 23bac <rtems_shell_debugrfs+0x11c> <== NOT EXECUTED 23b70: e5959008 ldr r9, [r5, #8] <== NOT EXECUTED 23b74: e1a07008 mov r7, r8 <== NOT EXECUTED 23b78: e2855008 add r5, r5, #8 <== NOT EXECUTED
{
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
if (strcmp (argv[arg + 1], table[t].name) == 0)
23b7c: e7941007 ldr r1, [r4, r7] <== NOT EXECUTED 23b80: e1a00009 mov r0, r9 <== NOT EXECUTED 23b84: eb0095ae bl 49244 <strcmp> <== NOT EXECUTED 23b88: e3500000 cmp r0, #0 <== NOT EXECUTED 23b8c: 0a000035 beq 23c68 <rtems_shell_debugrfs+0x1d8> <== NOT EXECUTED
else
{
rtems_rfs_file_system* fs;
if (rtems_rfs_get_fs (argv[arg], &fs) == 0)
{
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
23b90: e2888001 add r8, r8, #1 <== NOT EXECUTED 23b94: e3580005 cmp r8, #5 <== NOT EXECUTED 23b98: e287700c add r7, r7, #12 <== NOT EXECUTED 23b9c: 1afffff6 bne 23b7c <rtems_shell_debugrfs+0xec> <== NOT EXECUTED
if (strcmp (argv[arg + 1], table[t].name) == 0)
return table[t].handler (fs, argc - 2, argv + 2);
printf ("error: command not found: %s\n", argv[arg + 1]);
23ba0: e1a01009 mov r1, r9 <== NOT EXECUTED 23ba4: e59f0128 ldr r0, [pc, #296] ; 23cd4 <rtems_shell_debugrfs+0x244><== NOT EXECUTED 23ba8: eb008e6e bl 47568 <printf> <== NOT EXECUTED 23bac: e3a00001 mov r0, #1 <== NOT EXECUTED
}
}
return 1;
}
23bb0: e28dd08c add sp, sp, #140 ; 0x8c <== NOT EXECUTED
23bb4: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
return 1;
}
}
if ((argc - arg) < 2)
printf ("error: you need at least a path and command, try %s -h\n", argv[0]);
23bb8: e5951000 ldr r1, [r5] <== NOT EXECUTED 23bbc: e59f0114 ldr r0, [pc, #276] ; 23cd8 <rtems_shell_debugrfs+0x248><== NOT EXECUTED 23bc0: eb008e68 bl 47568 <printf> <== NOT EXECUTED 23bc4: e3a00001 mov r0, #1 <== NOT EXECUTED 23bc8: eafffff8 b 23bb0 <rtems_shell_debugrfs+0x120> <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
{
if (argv[arg][0] != '-')
break;
switch (argv[arg][1])
23bcc: e5d83001 ldrb r3, [r8, #1] <== NOT EXECUTED 23bd0: e3530068 cmp r3, #104 ; 0x68 <== NOT EXECUTED 23bd4: 0a000006 beq 23bf4 <rtems_shell_debugrfs+0x164> <== NOT EXECUTED 23bd8: e353006c cmp r3, #108 ; 0x6c <== NOT EXECUTED 23bdc: 0a000008 beq 23c04 <rtems_shell_debugrfs+0x174> <== NOT EXECUTED
printf ("%s: commands are:\n", argv[0]);
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
printf (" %s\t\t%s\n", table[t].name, table[t].help);
return 0;
default:
printf ("error: unknown option: %s\n", argv[arg]);
23be0: e1a01008 mov r1, r8 <== NOT EXECUTED 23be4: e59f00f0 ldr r0, [pc, #240] ; 23cdc <rtems_shell_debugrfs+0x24c><== NOT EXECUTED 23be8: eb008e5e bl 47568 <printf> <== NOT EXECUTED 23bec: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
23bf0: eaffffee b 23bb0 <rtems_shell_debugrfs+0x120> <== NOT EXECUTED
break;
switch (argv[arg][1])
{
case 'h':
rtems_rfs_shell_usage (argv[0]);
23bf4: e5950000 ldr r0, [r5] <== NOT EXECUTED 23bf8: ebfffb75 bl 229d4 <rtems_rfs_shell_usage> <== NOT EXECUTED 23bfc: e3a00000 mov r0, #0 <== NOT EXECUTED
return 0;
23c00: eaffffea b 23bb0 <rtems_shell_debugrfs+0x120> <== NOT EXECUTED
case 'l':
printf ("%s: commands are:\n", argv[0]);
23c04: e5951000 ldr r1, [r5] <== NOT EXECUTED 23c08: e59f00d0 ldr r0, [pc, #208] ; 23ce0 <rtems_shell_debugrfs+0x250><== NOT EXECUTED 23c0c: eb008e55 bl 47568 <printf> <== NOT EXECUTED
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
printf (" %s\t\t%s\n", table[t].name, table[t].help);
23c10: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED 23c14: e59d200c ldr r2, [sp, #12] <== NOT EXECUTED 23c18: e59f00c4 ldr r0, [pc, #196] ; 23ce4 <rtems_shell_debugrfs+0x254><== NOT EXECUTED 23c1c: eb008e51 bl 47568 <printf> <== NOT EXECUTED 23c20: e59d1010 ldr r1, [sp, #16] <== NOT EXECUTED 23c24: e59d2018 ldr r2, [sp, #24] <== NOT EXECUTED 23c28: e59f00b4 ldr r0, [pc, #180] ; 23ce4 <rtems_shell_debugrfs+0x254><== NOT EXECUTED 23c2c: eb008e4d bl 47568 <printf> <== NOT EXECUTED 23c30: e59d101c ldr r1, [sp, #28] <== NOT EXECUTED 23c34: e59d2024 ldr r2, [sp, #36] ; 0x24 <== NOT EXECUTED 23c38: e59f00a4 ldr r0, [pc, #164] ; 23ce4 <rtems_shell_debugrfs+0x254><== NOT EXECUTED 23c3c: eb008e49 bl 47568 <printf> <== NOT EXECUTED 23c40: e59d1028 ldr r1, [sp, #40] ; 0x28 <== NOT EXECUTED 23c44: e59d2030 ldr r2, [sp, #48] ; 0x30 <== NOT EXECUTED 23c48: e59f0094 ldr r0, [pc, #148] ; 23ce4 <rtems_shell_debugrfs+0x254><== NOT EXECUTED 23c4c: eb008e45 bl 47568 <printf> <== NOT EXECUTED 23c50: e59f008c ldr r0, [pc, #140] ; 23ce4 <rtems_shell_debugrfs+0x254><== NOT EXECUTED 23c54: e59d1034 ldr r1, [sp, #52] ; 0x34 <== NOT EXECUTED 23c58: e59d203c ldr r2, [sp, #60] ; 0x3c <== NOT EXECUTED 23c5c: eb008e41 bl 47568 <printf> <== NOT EXECUTED 23c60: e3a00000 mov r0, #0 <== NOT EXECUTED 23c64: eaffffd1 b 23bb0 <rtems_shell_debugrfs+0x120> <== NOT EXECUTED
rtems_rfs_file_system* fs;
if (rtems_rfs_get_fs (argv[arg], &fs) == 0)
{
for (t = 0; t < (sizeof (table) / sizeof (const rtems_rfs_shell_cmd)); t++)
if (strcmp (argv[arg + 1], table[t].name) == 0)
return table[t].handler (fs, argc - 2, argv + 2);
23c68: e28d208c add r2, sp, #140 ; 0x8c <== NOT EXECUTED 23c6c: e0888088 add r8, r8, r8, lsl #1 <== NOT EXECUTED 23c70: e0823108 add r3, r2, r8, lsl #2 <== NOT EXECUTED 23c74: e1a0000a mov r0, sl <== NOT EXECUTED 23c78: e2461002 sub r1, r6, #2 <== NOT EXECUTED 23c7c: e1a02005 mov r2, r5 <== NOT EXECUTED 23c80: e1a0e00f mov lr, pc <== NOT EXECUTED 23c84: e513f084 ldr pc, [r3, #-132] ; 0x84 <== NOT EXECUTED 23c88: eaffffc8 b 23bb0 <rtems_shell_debugrfs+0x120> <== NOT EXECUTED
return -1;
}
if (sb.f_fsid != RTEMS_RFS_SB_MAGIC)
{
printf ("error: path '%s' is not on an RFS file system\n", path);
23c8c: e1a01008 mov r1, r8 <== NOT EXECUTED 23c90: e59f0050 ldr r0, [pc, #80] ; 23ce8 <rtems_shell_debugrfs+0x258><== NOT EXECUTED 23c94: eb008e33 bl 47568 <printf> <== NOT EXECUTED 23c98: e3a00001 mov r0, #1 <== NOT EXECUTED 23c9c: eaffffc3 b 23bb0 <rtems_shell_debugrfs+0x120> <== NOT EXECUTED
int rc;
rc = statvfs (path, &sb);
if (rc < 0)
{
printf ("error: cannot statvfs path: %s: (%d) %s\n",
23ca0: eb007cd2 bl 42ff0 <__errno> <== NOT EXECUTED 23ca4: e5904000 ldr r4, [r0] <== NOT EXECUTED 23ca8: eb007cd0 bl 42ff0 <__errno> <== NOT EXECUTED 23cac: e5900000 ldr r0, [r0] <== NOT EXECUTED 23cb0: eb00963f bl 495b4 <strerror> <== NOT EXECUTED 23cb4: e1a01008 mov r1, r8 <== NOT EXECUTED 23cb8: e1a03000 mov r3, r0 <== NOT EXECUTED 23cbc: e1a02004 mov r2, r4 <== NOT EXECUTED 23cc0: e59f0024 ldr r0, [pc, #36] ; 23cec <rtems_shell_debugrfs+0x25c><== NOT EXECUTED 23cc4: eb008e27 bl 47568 <printf> <== NOT EXECUTED 23cc8: e3a00001 mov r0, #1 <== NOT EXECUTED 23ccc: eaffffb7 b 23bb0 <rtems_shell_debugrfs+0x120> <== NOT EXECUTED
00022a3c <rtems_shell_rfs_format>:
return 1;
}
int
rtems_shell_rfs_format (int argc, char* argv[])
{
22a3c: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
22a40: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
rtems_rfs_format_config config;
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
22a44: e3a05000 mov r5, #0 <== NOT EXECUTED 22a48: e28d3008 add r3, sp, #8 <== NOT EXECUTED 22a4c: e4835004 str r5, [r3], #4 <== NOT EXECUTED 22a50: e4835004 str r5, [r3], #4 <== NOT EXECUTED 22a54: e4835004 str r5, [r3], #4 <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
22a58: e3500001 cmp r0, #1 <== NOT EXECUTED
{
rtems_rfs_format_config config;
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
22a5c: e1a0800d mov r8, sp <== NOT EXECUTED
return 1;
}
int
rtems_shell_rfs_format (int argc, char* argv[])
{
22a60: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_rfs_format_config config;
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
22a64: e5835000 str r5, [r3] <== NOT EXECUTED
return 1;
}
int
rtems_shell_rfs_format (int argc, char* argv[])
{
22a68: e1a07001 mov r7, r1 <== NOT EXECUTED
rtems_rfs_format_config config;
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
22a6c: e58d5000 str r5, [sp] <== NOT EXECUTED 22a70: e58d5004 str r5, [sp, #4] <== NOT EXECUTED
for (arg = 1; arg < argc; arg++)
22a74: da00008b ble 22ca8 <rtems_shell_rfs_format+0x26c> <== NOT EXECUTED 22a78: e3a04001 mov r4, #1 <== NOT EXECUTED
}
config.group_inodes = strtoul (argv[arg], 0, 0);
break;
case 'I':
config.initialise_inodes = true;
22a7c: e1a0a004 mov sl, r4 <== NOT EXECUTED 22a80: ea000005 b 22a9c <rtems_shell_rfs_format+0x60> <== NOT EXECUTED
return 1;
}
}
else
{
if (!driver)
22a84: e3550000 cmp r5, #0 <== NOT EXECUTED 22a88: 1a000081 bne 22c94 <rtems_shell_rfs_format+0x258> <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
22a8c: e2844001 add r4, r4, #1 <== NOT EXECUTED 22a90: e1560004 cmp r6, r4 <== NOT EXECUTED 22a94: da00003c ble 22b8c <rtems_shell_rfs_format+0x150> <== NOT EXECUTED 22a98: e1a05009 mov r5, r9 <== NOT EXECUTED
{
if (argv[arg][0] == '-')
22a9c: e7979104 ldr r9, [r7, r4, lsl #2] <== NOT EXECUTED 22aa0: e5d93000 ldrb r3, [r9] <== NOT EXECUTED 22aa4: e353002d cmp r3, #45 ; 0x2d <== NOT EXECUTED 22aa8: 1afffff5 bne 22a84 <rtems_shell_rfs_format+0x48> <== NOT EXECUTED
{
switch (argv[arg][1])
22aac: e5d93001 ldrb r3, [r9, #1] <== NOT EXECUTED 22ab0: e2433049 sub r3, r3, #73 ; 0x49 <== NOT EXECUTED 22ab4: e353002d cmp r3, #45 ; 0x2d <== NOT EXECUTED 22ab8: 979ff103 ldrls pc, [pc, r3, lsl #2] <== NOT EXECUTED 22abc: ea00006e b 22c7c <rtems_shell_rfs_format+0x240> <== NOT EXECUTED 22ac0: 00022c70 .word 0x00022c70 <== NOT EXECUTED 22ac4: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22ac8: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22acc: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22ad0: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22ad4: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22ad8: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22adc: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22ae0: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22ae4: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22ae8: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22aec: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22af0: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22af4: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22af8: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22afc: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b00: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b04: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b08: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b0c: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b10: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b14: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b18: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b1c: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b20: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b24: 00022c48 .word 0x00022c48 <== NOT EXECUTED 22b28: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b2c: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b30: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b34: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b38: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b3c: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b40: 00022c20 .word 0x00022c20 <== NOT EXECUTED 22b44: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b48: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b4c: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b50: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b54: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b58: 00022bf8 .word 0x00022bf8 <== NOT EXECUTED 22b5c: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b60: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b64: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b68: 00022bd0 .word 0x00022bd0 <== NOT EXECUTED 22b6c: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b70: 00022c7c .word 0x00022c7c <== NOT EXECUTED 22b74: 00022b78 .word 0x00022b78 <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
22b78: e2844001 add r4, r4, #1 <== NOT EXECUTED 22b7c: e1560004 cmp r6, r4 <== NOT EXECUTED
if (argv[arg][0] == '-')
{
switch (argv[arg][1])
{
case 'v':
config.verbose = true;
22b80: e5cda015 strb sl, [sp, #21] <== NOT EXECUTED 22b84: e1a09005 mov r9, r5 <== NOT EXECUTED
const char* driver = NULL;
int arg;
memset (&config, 0, sizeof (rtems_rfs_format_config));
for (arg = 1; arg < argc; arg++)
22b88: caffffc2 bgt 22a98 <rtems_shell_rfs_format+0x5c> <== NOT EXECUTED
return 1;
}
}
}
if (!driver) {
22b8c: e3590000 cmp r9, #0 <== NOT EXECUTED 22b90: 0a000044 beq 22ca8 <rtems_shell_rfs_format+0x26c> <== NOT EXECUTED
printf ("error: no driver name provided\n");
return 1;
}
if (rtems_rfs_format (driver, &config) < 0)
22b94: e1a0100d mov r1, sp <== NOT EXECUTED 22b98: e1a00009 mov r0, r9 <== NOT EXECUTED 22b9c: eb00640d bl 3bbd8 <rtems_rfs_format> <== NOT EXECUTED 22ba0: e3500000 cmp r0, #0 <== NOT EXECUTED 22ba4: a3a00000 movge r0, #0 <== NOT EXECUTED 22ba8: aa000037 bge 22c8c <rtems_shell_rfs_format+0x250> <== NOT EXECUTED
{
printf ("error: format of %s failed: %s\n",
22bac: eb00810f bl 42ff0 <__errno> <== NOT EXECUTED 22bb0: e5900000 ldr r0, [r0] <== NOT EXECUTED 22bb4: eb009a7e bl 495b4 <strerror> <== NOT EXECUTED 22bb8: e1a01009 mov r1, r9 <== NOT EXECUTED 22bbc: e1a02000 mov r2, r0 <== NOT EXECUTED 22bc0: e59f0130 ldr r0, [pc, #304] ; 22cf8 <rtems_shell_rfs_format+0x2bc><== NOT EXECUTED 22bc4: eb009267 bl 47568 <printf> <== NOT EXECUTED 22bc8: e3a00001 mov r0, #1 <== NOT EXECUTED
driver, strerror (errno));
return 1;
22bcc: ea00002e b 22c8c <rtems_shell_rfs_format+0x250> <== NOT EXECUTED
case 'v':
config.verbose = true;
break;
case 's':
arg++;
22bd0: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
22bd4: e1560004 cmp r6, r4 <== NOT EXECUTED 22bd8: da00003a ble 22cc8 <rtems_shell_rfs_format+0x28c> <== NOT EXECUTED
{
printf ("error: block size needs an argument\n");
return 1;
}
config.block_size = strtoul (argv[arg], 0, 0);
22bdc: e3a01000 mov r1, #0 <== NOT EXECUTED 22be0: e7970104 ldr r0, [r7, r4, lsl #2] <== NOT EXECUTED 22be4: e1a02001 mov r2, r1 <== NOT EXECUTED 22be8: eb00a119 bl 4b054 <strtoul> <== NOT EXECUTED 22bec: e1a09005 mov r9, r5 <== NOT EXECUTED 22bf0: e58d0000 str r0, [sp] <== NOT EXECUTED
break;
22bf4: eaffffa4 b 22a8c <rtems_shell_rfs_format+0x50> <== NOT EXECUTED
case 'I':
config.initialise_inodes = true;
break;
case 'o':
arg++;
22bf8: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
22bfc: e1560004 cmp r6, r4 <== NOT EXECUTED 22c00: da000038 ble 22ce8 <rtems_shell_rfs_format+0x2ac> <== NOT EXECUTED
{
printf ("error: inode percentage overhead needs an argument\n");
return 1;
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
22c04: e3a01000 mov r1, #0 <== NOT EXECUTED 22c08: e7970104 ldr r0, [r7, r4, lsl #2] <== NOT EXECUTED 22c0c: e1a02001 mov r2, r1 <== NOT EXECUTED 22c10: eb00a10f bl 4b054 <strtoul> <== NOT EXECUTED 22c14: e1a09005 mov r9, r5 <== NOT EXECUTED 22c18: e58d000c str r0, [sp, #12] <== NOT EXECUTED
break;
22c1c: eaffff9a b 22a8c <rtems_shell_rfs_format+0x50> <== NOT EXECUTED
}
config.group_blocks = strtoul (argv[arg], 0, 0);
break;
case 'i':
arg++;
22c20: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
22c24: e1560004 cmp r6, r4 <== NOT EXECUTED 22c28: da00002a ble 22cd8 <rtems_shell_rfs_format+0x29c> <== NOT EXECUTED
{
printf ("error: group inode count needs an argument\n");
return 1;
}
config.group_inodes = strtoul (argv[arg], 0, 0);
22c2c: e3a01000 mov r1, #0 <== NOT EXECUTED 22c30: e7970104 ldr r0, [r7, r4, lsl #2] <== NOT EXECUTED 22c34: e1a02001 mov r2, r1 <== NOT EXECUTED 22c38: eb00a105 bl 4b054 <strtoul> <== NOT EXECUTED 22c3c: e1a09005 mov r9, r5 <== NOT EXECUTED 22c40: e58d0008 str r0, [sp, #8] <== NOT EXECUTED
break;
22c44: eaffff90 b 22a8c <rtems_shell_rfs_format+0x50> <== NOT EXECUTED
}
config.block_size = strtoul (argv[arg], 0, 0);
break;
case 'b':
arg++;
22c48: e2844001 add r4, r4, #1 <== NOT EXECUTED
if (arg >= argc)
22c4c: e1560004 cmp r6, r4 <== NOT EXECUTED 22c50: da000018 ble 22cb8 <rtems_shell_rfs_format+0x27c> <== NOT EXECUTED
{
printf ("error: group block count needs an argument\n");
return 1;
}
config.group_blocks = strtoul (argv[arg], 0, 0);
22c54: e3a01000 mov r1, #0 <== NOT EXECUTED 22c58: e7970104 ldr r0, [r7, r4, lsl #2] <== NOT EXECUTED 22c5c: e1a02001 mov r2, r1 <== NOT EXECUTED 22c60: eb00a0fb bl 4b054 <strtoul> <== NOT EXECUTED 22c64: e1a09005 mov r9, r5 <== NOT EXECUTED 22c68: e58d0004 str r0, [sp, #4] <== NOT EXECUTED
break;
22c6c: eaffff86 b 22a8c <rtems_shell_rfs_format+0x50> <== NOT EXECUTED
}
config.group_inodes = strtoul (argv[arg], 0, 0);
break;
case 'I':
config.initialise_inodes = true;
22c70: e5cda014 strb sl, [sp, #20] <== NOT EXECUTED 22c74: e1a09005 mov r9, r5 <== NOT EXECUTED
break;
22c78: eaffff83 b 22a8c <rtems_shell_rfs_format+0x50> <== NOT EXECUTED
}
config.inode_overhead = strtoul (argv[arg], 0, 0);
break;
default:
printf ("error: invalid option: %s\n", argv[arg]);
22c7c: e1a01009 mov r1, r9 <== NOT EXECUTED 22c80: e59f0074 ldr r0, [pc, #116] ; 22cfc <rtems_shell_rfs_format+0x2c0><== NOT EXECUTED 22c84: eb009237 bl 47568 <printf> <== NOT EXECUTED 22c88: e3a00001 mov r0, #1 <== NOT EXECUTED
driver, strerror (errno));
return 1;
}
return 0;
}
22c8c: e28dd018 add sp, sp, #24 <== NOT EXECUTED
22c90: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
{
if (!driver)
driver = argv[arg];
else
{
printf ("error: only one driver name allowed: %s\n", argv[arg]);
22c94: e1a01009 mov r1, r9 <== NOT EXECUTED 22c98: e59f0060 ldr r0, [pc, #96] ; 22d00 <rtems_shell_rfs_format+0x2c4><== NOT EXECUTED 22c9c: eb009231 bl 47568 <printf> <== NOT EXECUTED 22ca0: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
22ca4: eafffff8 b 22c8c <rtems_shell_rfs_format+0x250> <== NOT EXECUTED
}
}
}
if (!driver) {
printf ("error: no driver name provided\n");
22ca8: e59f0054 ldr r0, [pc, #84] ; 22d04 <rtems_shell_rfs_format+0x2c8><== NOT EXECUTED 22cac: eb0092d2 bl 477fc <puts> <== NOT EXECUTED 22cb0: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
22cb4: eafffff4 b 22c8c <rtems_shell_rfs_format+0x250> <== NOT EXECUTED
case 'b':
arg++;
if (arg >= argc)
{
printf ("error: group block count needs an argument\n");
22cb8: e59f0048 ldr r0, [pc, #72] ; 22d08 <rtems_shell_rfs_format+0x2cc><== NOT EXECUTED 22cbc: eb0092ce bl 477fc <puts> <== NOT EXECUTED 22cc0: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
22cc4: eafffff0 b 22c8c <rtems_shell_rfs_format+0x250> <== NOT EXECUTED
case 's':
arg++;
if (arg >= argc)
{
printf ("error: block size needs an argument\n");
22cc8: e59f003c ldr r0, [pc, #60] ; 22d0c <rtems_shell_rfs_format+0x2d0><== NOT EXECUTED 22ccc: eb0092ca bl 477fc <puts> <== NOT EXECUTED 22cd0: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
22cd4: eaffffec b 22c8c <rtems_shell_rfs_format+0x250> <== NOT EXECUTED
case 'i':
arg++;
if (arg >= argc)
{
printf ("error: group inode count needs an argument\n");
22cd8: e59f0030 ldr r0, [pc, #48] ; 22d10 <rtems_shell_rfs_format+0x2d4><== NOT EXECUTED 22cdc: eb0092c6 bl 477fc <puts> <== NOT EXECUTED 22ce0: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
22ce4: eaffffe8 b 22c8c <rtems_shell_rfs_format+0x250> <== NOT EXECUTED
case 'o':
arg++;
if (arg >= argc)
{
printf ("error: inode percentage overhead needs an argument\n");
22ce8: e59f0024 ldr r0, [pc, #36] ; 22d14 <rtems_shell_rfs_format+0x2d8><== NOT EXECUTED 22cec: eb0092c2 bl 477fc <puts> <== NOT EXECUTED 22cf0: e3a00001 mov r0, #1 <== NOT EXECUTED
return 1;
22cf4: eaffffe4 b 22c8c <rtems_shell_rfs_format+0x250> <== NOT EXECUTED
0000635c <rtems_stack_checker_is_blown>:
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
635c: e92d4830 push {r4, r5, fp, lr}
Stack_Control *the_stack = &_Thread_Executing->Start.Initial_stack;
6360: e59f4078 ldr r4, [pc, #120] ; 63e0 <rtems_stack_checker_is_blown+0x84>
6364: e5943000 ldr r3, [r4]
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
6368: e59300c4 ldr r0, [r3, #196] ; 0xc4
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
{
636c: e28db00c add fp, sp, #12
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
6370: e15b0000 cmp fp, r0
6374: 33a05000 movcc r5, #0
6378: 3a000004 bcc 6390 <rtems_stack_checker_is_blown+0x34>
}
/*
* Check if blown
*/
bool rtems_stack_checker_is_blown( void )
637c: e59350c0 ldr r5, [r3, #192] ; 0xc0
6380: e0805005 add r5, r0, r5
6384: e15b0005 cmp fp, r5
6388: 83a05000 movhi r5, #0
638c: 93a05001 movls r5, #1
/*
* The stack checker must be initialized before the pattern is there
* to check.
*/
if ( Stack_check_Initialized ) {
6390: e59f304c ldr r3, [pc, #76] ; 63e4 <rtems_stack_checker_is_blown+0x88>
6394: e5933000 ldr r3, [r3]
6398: e3530000 cmp r3, #0
639c: 03a01001 moveq r1, #1
63a0: 0a000005 beq 63bc <rtems_stack_checker_is_blown+0x60>
pattern_ok = (!memcmp(
63a4: e59f103c ldr r1, [pc, #60] ; 63e8 <rtems_stack_checker_is_blown+0x8c>
63a8: e2800008 add r0, r0, #8
63ac: e3a02010 mov r2, #16
63b0: eb00ff94 bl 46208 <memcmp>
63b4: e2701001 rsbs r1, r0, #1
63b8: 33a01000 movcc r1, #0
}
/*
* The Stack Pointer and the Pattern Area are OK so return false.
*/
if ( sp_ok && pattern_ok )
63bc: e3550000 cmp r5, #0
63c0: 0a000002 beq 63d0 <rtems_stack_checker_is_blown+0x74>
63c4: e3510000 cmp r1, #0
63c8: 13a00000 movne r0, #0
63cc: 18bd8830 popne {r4, r5, fp, pc}
return false;
/*
* Let's report as much as we can.
*/
Stack_check_report_blown_task( _Thread_Executing, pattern_ok );
63d0: e5940000 ldr r0, [r4] <== NOT EXECUTED
63d4: ebffffb3 bl 62a8 <Stack_check_report_blown_task> <== NOT EXECUTED
63d8: e3a00001 mov r0, #1 <== NOT EXECUTED
return true; }
63dc: e8bd8830 pop {r4, r5, fp, pc} <== NOT EXECUTED
00006298 <rtems_stack_checker_report_usage>:
void rtems_stack_checker_report_usage( void )
{
rtems_stack_checker_report_usage_with_plugin( NULL, printk_plugin );
6298: e59f1004 ldr r1, [pc, #4] ; 62a4 <rtems_stack_checker_report_usage+0xc><== NOT EXECUTED
629c: e3a00000 mov r0, #0 <== NOT EXECUTED
62a0: eaffffe3 b 6234 <rtems_stack_checker_report_usage_with_plugin><== NOT EXECUTED
00006234 <rtems_stack_checker_report_usage_with_plugin>:
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
6234: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
print_context = context;
6238: e59f4048 ldr r4, [pc, #72] ; 6288 <rtems_stack_checker_report_usage_with_plugin+0x54><== NOT EXECUTED
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
623c: e1a05001 mov r5, r1 <== NOT EXECUTED
6240: e1a06000 mov r6, r0 <== NOT EXECUTED
print_context = context; print_handler = print;
6244: e5841004 str r1, [r4, #4] <== NOT EXECUTED
void rtems_stack_checker_report_usage_with_plugin(
void *context,
rtems_printk_plugin_t print
)
{
print_context = context;
6248: e5840008 str r0, [r4, #8] <== NOT EXECUTED
print_handler = print;
(*print)( context, "Stack usage by thread\n");
624c: e59f1038 ldr r1, [pc, #56] ; 628c <rtems_stack_checker_report_usage_with_plugin+0x58><== NOT EXECUTED
6250: e1a0e00f mov lr, pc <== NOT EXECUTED
6254: e12fff15 bx r5 <== NOT EXECUTED
(*print)( context,
6258: e59f1030 ldr r1, [pc, #48] ; 6290 <rtems_stack_checker_report_usage_with_plugin+0x5c><== NOT EXECUTED
625c: e1a00006 mov r0, r6 <== NOT EXECUTED
6260: e1a0e00f mov lr, pc <== NOT EXECUTED
6264: e12fff15 bx r5 <== NOT EXECUTED
" ID NAME LOW HIGH CURRENT AVAILABLE USED\n"
);
/* iterate over all threads and dump the usage */
rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage );
6268: e59f0024 ldr r0, [pc, #36] ; 6294 <rtems_stack_checker_report_usage_with_plugin+0x60><== NOT EXECUTED
626c: eb001df4 bl da44 <rtems_iterate_over_all_threads> <== NOT EXECUTED
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
6270: e3e00000 mvn r0, #0 <== NOT EXECUTED
6274: ebffff9d bl 60f0 <Stack_check_Dump_threads_usage> <== NOT EXECUTED
print_context = NULL;
6278: e3a03000 mov r3, #0 <== NOT EXECUTED
print_handler = NULL;
627c: e5843004 str r3, [r4, #4] <== NOT EXECUTED
rtems_iterate_over_all_threads( Stack_check_Dump_threads_usage );
/* dump interrupt stack info if any */
Stack_check_Dump_threads_usage((Thread_Control *) -1);
print_context = NULL;
6280: e5843008 str r3, [r4, #8] <== NOT EXECUTED
print_handler = NULL;
}
6284: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
000063ec <rtems_stack_checker_switch_extension>:
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
63ec: e92d4810 push {r4, fp, lr}
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = (void *) Stack_check_Get_pattern_area(the_stack)->pattern;
63f0: e59030c4 ldr r3, [r0, #196] ; 0xc4
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
63f4: e28db008 add fp, sp, #8
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
63f8: e15b0003 cmp fp, r3
*/
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
63fc: e1a04000 mov r4, r0
Stack_Control *the_stack = &running->Start.Initial_stack;
void *pattern;
bool sp_ok;
bool pattern_ok = true;
pattern = (void *) Stack_check_Get_pattern_area(the_stack)->pattern;
6400: e2830008 add r0, r3, #8
)
{
#if defined(__GNUC__)
void *sp = __builtin_frame_address(0);
if ( sp < the_stack->area ) {
6404: 3a000003 bcc 6418 <rtems_stack_checker_switch_extension+0x2c>
void rtems_stack_checker_switch_extension(
Thread_Control *running __attribute__((unused)),
Thread_Control *heir __attribute__((unused))
)
{
Stack_Control *the_stack = &running->Start.Initial_stack;
6408: e59420c0 ldr r2, [r4, #192] ; 0xc0
640c: e0833002 add r3, r3, r2
6410: e15b0003 cmp fp, r3
6414: 9a000007 bls 6438 <rtems_stack_checker_switch_extension+0x4c>
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
6418: e59f1034 ldr r1, [pc, #52] ; 6454 <rtems_stack_checker_switch_extension+0x68><== NOT EXECUTED
641c: e3a02010 mov r2, #16 <== NOT EXECUTED
6420: eb00ff78 bl 46208 <memcmp> <== NOT EXECUTED
6424: e2701001 rsbs r1, r0, #1 <== NOT EXECUTED
6428: 33a01000 movcc r1, #0 <== NOT EXECUTED
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( running, pattern_ok );
642c: e1a00004 mov r0, r4
} }
6430: e8bd4810 pop {r4, fp, lr}
pattern_ok = (!memcmp( pattern,
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
Stack_check_report_blown_task( running, pattern_ok );
6434: eaffff9b b 62a8 <Stack_check_report_blown_task>
/*
* Check for an out of bounds stack pointer or an overwrite
*/
sp_ok = Stack_check_Frame_pointer_in_range( the_stack );
pattern_ok = (!memcmp( pattern,
6438: e59f1014 ldr r1, [pc, #20] ; 6454 <rtems_stack_checker_switch_extension+0x68>
643c: e3a02010 mov r2, #16
6440: eb00ff70 bl 46208 <memcmp>
(void *) Stack_check_Pattern.pattern, PATTERN_SIZE_BYTES));
if ( !sp_ok || !pattern_ok ) {
6444: e3500000 cmp r0, #0
6448: 13a01000 movne r1, #0
644c: 1afffff6 bne 642c <rtems_stack_checker_switch_extension+0x40>
6450: e8bd8810 pop {r4, fp, pc}
0000b8a8 <rtems_string_to_double>:
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
b8a8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
double result;
char *end;
if ( !n )
b8ac: e2514000 subs r4, r1, #0
rtems_status_code rtems_string_to_double (
const char *s,
double *n,
char **endptr
)
{
b8b0: e1a07000 mov r7, r0
b8b4: e24dd004 sub sp, sp, #4
b8b8: e1a08002 mov r8, r2
double result;
char *end;
if ( !n )
b8bc: 03a00009 moveq r0, #9
b8c0: 0a000017 beq b924 <rtems_string_to_double+0x7c>
return RTEMS_INVALID_ADDRESS;
errno = 0;
b8c4: eb0008d5 bl dc20 <__errno>
b8c8: e3a03000 mov r3, #0
b8cc: e5803000 str r3, [r0]
*n = 0;
b8d0: e3a02000 mov r2, #0
b8d4: e3a03000 mov r3, #0
b8d8: e884000c stm r4, {r2, r3}
result = strtod( s, &end );
b8dc: e1a00007 mov r0, r7
b8e0: e1a0100d mov r1, sp
b8e4: eb00144b bl 10a18 <strtod>
if ( endptr )
b8e8: e3580000 cmp r8, #0
*endptr = end;
b8ec: 159d3000 ldrne r3, [sp]
b8f0: 059d3000 ldreq r3, [sp]
b8f4: 15883000 strne r3, [r8]
if ( end == s )
b8f8: e1530007 cmp r3, r7
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtod( s, &end );
b8fc: e1a05000 mov r5, r0
b900: e1a06001 mov r6, r1
if ( endptr )
*endptr = end;
if ( end == s )
b904: 03a0000b moveq r0, #11
b908: 0a000005 beq b924 <rtems_string_to_double+0x7c>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
b90c: eb0008c3 bl dc20 <__errno>
b910: e5903000 ldr r3, [r0]
b914: e3530022 cmp r3, #34 ; 0x22
b918: 0a000003 beq b92c <rtems_string_to_double+0x84>
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
b91c: e8840060 stm r4, {r5, r6}
b920: e3a00000 mov r0, #0
return RTEMS_SUCCESSFUL;
}
b924: e28dd004 add sp, sp, #4
b928: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
b92c: e1a00005 mov r0, r5
b930: e1a01006 mov r1, r6
b934: e3a02000 mov r2, #0
b938: e3a03000 mov r3, #0
b93c: ebffdd61 bl 2ec8 <__cmpdf2>
b940: e3500000 cmp r0, #0
b944: 0a00000e beq b984 <rtems_string_to_double+0xdc>
b948: e3e03102 mvn r3, #-2147483648 ; 0x80000000
b94c: e1a00005 mov r0, r5
b950: e1a01006 mov r1, r6
b954: e3e02000 mvn r2, #0
b958: e2433601 sub r3, r3, #1048576 ; 0x100000
b95c: ebffdd55 bl 2eb8 <__gedf2>
b960: e3500000 cmp r0, #0
b964: ca000006 bgt b984 <rtems_string_to_double+0xdc>
b968: e1a00005 mov r0, r5 <== NOT EXECUTED
b96c: e1a01006 mov r1, r6 <== NOT EXECUTED
b970: e3e02000 mvn r2, #0 <== NOT EXECUTED
b974: e3e03601 mvn r3, #1048576 ; 0x100000 <== NOT EXECUTED
b978: ebffdd50 bl 2ec0 <__ledf2> <== NOT EXECUTED
b97c: e3500000 cmp r0, #0 <== NOT EXECUTED
b980: aaffffe5 bge b91c <rtems_string_to_double+0x74> <== NOT EXECUTED
(( result == 0 ) || ( result == HUGE_VAL ) || ( result == -HUGE_VAL )))
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
b984: e3a0000a mov r0, #10
b988: eaffffe5 b b924 <rtems_string_to_double+0x7c>
0000b98c <rtems_string_to_float>:
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
b98c: e92d40f0 push {r4, r5, r6, r7, lr}
float result;
char *end;
if ( !n )
b990: e2515000 subs r5, r1, #0
rtems_status_code rtems_string_to_float (
const char *s,
float *n,
char **endptr
)
{
b994: e1a04000 mov r4, r0
b998: e24dd004 sub sp, sp, #4
b99c: e1a06002 mov r6, r2
float result;
char *end;
if ( !n )
b9a0: 03a00009 moveq r0, #9
b9a4: 0a000015 beq ba00 <rtems_string_to_float+0x74>
return RTEMS_INVALID_ADDRESS;
errno = 0;
b9a8: eb00089c bl dc20 <__errno>
b9ac: e3a03000 mov r3, #0
b9b0: e5803000 str r3, [r0]
*n = 0;
b9b4: e3a03000 mov r3, #0
b9b8: e5853000 str r3, [r5]
result = strtof( s, &end );
b9bc: e1a00004 mov r0, r4
b9c0: e1a0100d mov r1, sp
b9c4: eb001400 bl 109cc <strtof>
if ( endptr )
b9c8: e3560000 cmp r6, #0
*endptr = end;
b9cc: 159d3000 ldrne r3, [sp]
b9d0: 059d3000 ldreq r3, [sp]
b9d4: 15863000 strne r3, [r6]
if ( end == s )
b9d8: e1530004 cmp r3, r4
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtof( s, &end );
b9dc: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
b9e0: 03a0000b moveq r0, #11
b9e4: 0a000005 beq ba00 <rtems_string_to_float+0x74>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
b9e8: eb00088c bl dc20 <__errno>
b9ec: e5903000 ldr r3, [r0]
b9f0: e3530022 cmp r3, #34 ; 0x22
b9f4: 0a000003 beq ba08 <rtems_string_to_float+0x7c>
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
b9f8: e5857000 str r7, [r5]
b9fc: e3a00000 mov r0, #0
return RTEMS_SUCCESSFUL;
}
ba00: e28dd004 add sp, sp, #4
ba04: e8bd80f0 pop {r4, r5, r6, r7, pc}
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
ba08: e1a00007 mov r0, r7
ba0c: e3a01000 mov r1, #0
ba10: ebffdd77 bl 2ff4 <__cmpsf2>
ba14: e3500000 cmp r0, #0
ba18: 0a00000a beq ba48 <rtems_string_to_float+0xbc>
ba1c: e3e01102 mvn r1, #-2147483648 ; 0x80000000
ba20: e1a00007 mov r0, r7
ba24: e2411502 sub r1, r1, #8388608 ; 0x800000
ba28: ebffdd6d bl 2fe4 <__gesf2>
ba2c: e3500000 cmp r0, #0
ba30: ca000004 bgt ba48 <rtems_string_to_float+0xbc>
ba34: e1a00007 mov r0, r7 <== NOT EXECUTED
ba38: e3e01502 mvn r1, #8388608 ; 0x800000 <== NOT EXECUTED
ba3c: ebffdd6a bl 2fec <__lesf2> <== NOT EXECUTED
ba40: e3500000 cmp r0, #0 <== NOT EXECUTED
ba44: aaffffeb bge b9f8 <rtems_string_to_float+0x6c> <== NOT EXECUTED
(( result == 0 ) || ( result == HUGE_VALF ) || ( result == -HUGE_VALF )))
return RTEMS_INVALID_NUMBER;
*n = result;
return RTEMS_SUCCESSFUL;
ba48: e3a0000a mov r0, #10
ba4c: eaffffeb b ba00 <rtems_string_to_float+0x74>
0001ee48 <rtems_string_to_int>:
const char *s,
int *n,
char **endptr,
int base
)
{
1ee48: e92d40f0 push {r4, r5, r6, r7, lr}
long result;
char *end;
if ( !n )
1ee4c: e2516000 subs r6, r1, #0
const char *s,
int *n,
char **endptr,
int base
)
{
1ee50: e1a04000 mov r4, r0 1ee54: e24dd004 sub sp, sp, #4 1ee58: e1a05002 mov r5, r2 1ee5c: e1a07003 mov r7, r3
long result;
char *end;
if ( !n )
1ee60: 03a00009 moveq r0, #9
1ee64: 0a000015 beq 1eec0 <rtems_string_to_int+0x78>
return RTEMS_INVALID_ADDRESS;
errno = 0;
1ee68: eb009060 bl 42ff0 <__errno> 1ee6c: e3a03000 mov r3, #0 1ee70: e5803000 str r3, [r0]
*n = 0;
result = strtol( s, &end, base );
1ee74: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
1ee78: e5863000 str r3, [r6]
result = strtol( s, &end, base );
1ee7c: e1a00004 mov r0, r4 1ee80: e1a0100d mov r1, sp 1ee84: eb00af55 bl 4abe0 <strtol>
if ( endptr )
1ee88: e3550000 cmp r5, #0
*endptr = end;
1ee8c: 159d3000 ldrne r3, [sp] 1ee90: 059d3000 ldreq r3, [sp] 1ee94: 15853000 strne r3, [r5]
if ( end == s )
1ee98: e1530004 cmp r3, r4
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtol( s, &end, base );
1ee9c: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
1eea0: 03a0000b moveq r0, #11
1eea4: 0a000005 beq 1eec0 <rtems_string_to_int+0x78>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1eea8: eb009050 bl 42ff0 <__errno> 1eeac: e5903000 ldr r3, [r0] 1eeb0: e3530022 cmp r3, #34 ; 0x22
1eeb4: 0a000003 beq 1eec8 <rtems_string_to_int+0x80>
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
1eeb8: e5867000 str r7, [r6] 1eebc: e3a00000 mov r0, #0
return RTEMS_SUCCESSFUL;
}
1eec0: e28dd004 add sp, sp, #4
1eec4: e8bd80f0 pop {r4, r5, r6, r7, pc}
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1eec8: e3770106 cmn r7, #-2147483647 ; 0x80000001 1eecc: 13570000 cmpne r7, #0
1eed0: 0a000001 beq 1eedc <rtems_string_to_int+0x94>
1eed4: e3570102 cmp r7, #-2147483648 ; 0x80000000 <== NOT EXECUTED 1eed8: 1afffff6 bne 1eeb8 <rtems_string_to_int+0x70> <== NOT EXECUTED
}
#endif
*n = result;
return RTEMS_SUCCESSFUL;
1eedc: e3a0000a mov r0, #10 1eee0: eafffff6 b 1eec0 <rtems_string_to_int+0x78>
0001eeec <rtems_string_to_unsigned_char>:
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
1eeec: e92d40f0 push {r4, r5, r6, r7, lr}
unsigned long result;
char *end;
if ( !n )
1eef0: e2516000 subs r6, r1, #0
const char *s,
unsigned char *n,
char **endptr,
int base
)
{
1eef4: e1a04000 mov r4, r0 1eef8: e24dd004 sub sp, sp, #4 1eefc: e1a05002 mov r5, r2 1ef00: e1a07003 mov r7, r3
unsigned long result;
char *end;
if ( !n )
1ef04: 03a00009 moveq r0, #9
1ef08: 0a000017 beq 1ef6c <rtems_string_to_unsigned_char+0x80>
return RTEMS_INVALID_ADDRESS;
errno = 0;
1ef0c: eb009037 bl 42ff0 <__errno> 1ef10: e3a03000 mov r3, #0 1ef14: e5803000 str r3, [r0]
*n = 0;
result = strtoul( s, &end, base );
1ef18: e1a02007 mov r2, r7
if ( !n )
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
1ef1c: e5c63000 strb r3, [r6]
result = strtoul( s, &end, base );
1ef20: e1a00004 mov r0, r4 1ef24: e1a0100d mov r1, sp 1ef28: eb00b049 bl 4b054 <strtoul>
if ( endptr )
1ef2c: e3550000 cmp r5, #0
*endptr = end;
1ef30: 159d3000 ldrne r3, [sp] 1ef34: 059d3000 ldreq r3, [sp] 1ef38: 15853000 strne r3, [r5]
if ( end == s )
1ef3c: e1530004 cmp r3, r4
return RTEMS_INVALID_ADDRESS;
errno = 0;
*n = 0;
result = strtoul( s, &end, base );
1ef40: e1a07000 mov r7, r0
if ( endptr )
*endptr = end;
if ( end == s )
1ef44: 03a0000b moveq r0, #11
1ef48: 0a000007 beq 1ef6c <rtems_string_to_unsigned_char+0x80>
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1ef4c: eb009027 bl 42ff0 <__errno> 1ef50: e5903000 ldr r3, [r0] 1ef54: e3530022 cmp r3, #34 ; 0x22
1ef58: 0a000005 beq 1ef74 <rtems_string_to_unsigned_char+0x88>
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
1ef5c: e35700ff cmp r7, #255 ; 0xff
errno = ERANGE;
return RTEMS_INVALID_NUMBER;
}
#endif
*n = result;
1ef60: 95c67000 strbls r7, [r6] 1ef64: 93a00000 movls r0, #0
if ( ( errno == ERANGE ) &&
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
1ef68: 8a000006 bhi 1ef88 <rtems_string_to_unsigned_char+0x9c>
#endif
*n = result;
return RTEMS_SUCCESSFUL;
}
1ef6c: e28dd004 add sp, sp, #4
1ef70: e8bd80f0 pop {r4, r5, r6, r7, pc}
*endptr = end;
if ( end == s )
return RTEMS_NOT_DEFINED;
if ( ( errno == ERANGE ) &&
1ef74: e2473001 sub r3, r7, #1 <== NOT EXECUTED 1ef78: e3730003 cmn r3, #3 <== NOT EXECUTED 1ef7c: 9afffff6 bls 1ef5c <rtems_string_to_unsigned_char+0x70> <== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
errno = ERANGE;
1ef80: e3a0000a mov r0, #10 <== NOT EXECUTED
return RTEMS_INVALID_NUMBER;
1ef84: eafffff8 b 1ef6c <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
(( result == 0 ) || ( result == ULONG_MAX )))
return RTEMS_INVALID_NUMBER;
#if (UCHAR_MAX < ULONG_MAX)
if ( result > UCHAR_MAX ) {
errno = ERANGE;
1ef88: eb009018 bl 42ff0 <__errno> <== NOT EXECUTED 1ef8c: e3a03022 mov r3, #34 ; 0x22 <== NOT EXECUTED 1ef90: e5803000 str r3, [r0] <== NOT EXECUTED 1ef94: e3a0000a mov r0, #10 <== NOT EXECUTED 1ef98: eafffff3 b 1ef6c <rtems_string_to_unsigned_char+0x80> <== NOT EXECUTED
00004644 <rtems_termios_baud_to_index>:
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
4644: e3500009 cmp r0, #9
4648: 012fff1e bxeq lr
464c: da000013 ble 46a0 <rtems_termios_baud_to_index+0x5c>
4650: e350000e cmp r0, #14 <== NOT EXECUTED
4654: 012fff1e bxeq lr <== NOT EXECUTED
4658: da00001b ble 46cc <rtems_termios_baud_to_index+0x88> <== NOT EXECUTED
465c: e3a03a01 mov r3, #4096 ; 0x1000 <== NOT EXECUTED
4660: e2833002 add r3, r3, #2 <== NOT EXECUTED
4664: e1500003 cmp r0, r3 <== NOT EXECUTED
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
4668: 03a00011 moveq r0, #17 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
466c: 012fff1e bxeq lr <== NOT EXECUTED
4670: da000028 ble 4718 <rtems_termios_baud_to_index+0xd4> <== NOT EXECUTED
4674: e3a03a01 mov r3, #4096 ; 0x1000 <== NOT EXECUTED
4678: e2833003 add r3, r3, #3 <== NOT EXECUTED
467c: e1500003 cmp r0, r3 <== NOT EXECUTED
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
4680: 03a00012 moveq r0, #18 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
4684: 012fff1e bxeq lr <== NOT EXECUTED
4688: e3a03a01 mov r3, #4096 ; 0x1000 <== NOT EXECUTED
468c: e2833004 add r3, r3, #4 <== NOT EXECUTED
4690: e1500003 cmp r0, r3 <== NOT EXECUTED
4694: 1a00001d bne 4710 <rtems_termios_baud_to_index+0xcc> <== NOT EXECUTED
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
4698: e3a00013 mov r0, #19 <== NOT EXECUTED
case B460800: baud_index = 19; break;
469c: e12fff1e bx lr <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
46a0: e3500004 cmp r0, #4
46a4: 012fff1e bxeq lr
46a8: ca000010 bgt 46f0 <rtems_termios_baud_to_index+0xac>
46ac: e3500001 cmp r0, #1
46b0: 012fff1e bxeq lr
46b4: da00001f ble 4738 <rtems_termios_baud_to_index+0xf4>
46b8: e3500002 cmp r0, #2 <== NOT EXECUTED
46bc: 012fff1e bxeq lr <== NOT EXECUTED
46c0: e3500003 cmp r0, #3 <== NOT EXECUTED
46c4: 1a000011 bne 4710 <rtems_termios_baud_to_index+0xcc> <== NOT EXECUTED
46c8: e12fff1e bx lr <== NOT EXECUTED
46cc: e350000b cmp r0, #11 <== NOT EXECUTED
46d0: 012fff1e bxeq lr <== NOT EXECUTED
case B134: baud_index = 4; break;
case B150: baud_index = 5; break;
case B200: baud_index = 6; break;
case B300: baud_index = 7; break;
case B600: baud_index = 8; break;
case B1200: baud_index = 9; break;
46d4: b3a0000a movlt r0, #10 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
46d8: b12fff1e bxlt lr <== NOT EXECUTED
46dc: e350000c cmp r0, #12 <== NOT EXECUTED
46e0: 012fff1e bxeq lr <== NOT EXECUTED
46e4: e350000d cmp r0, #13 <== NOT EXECUTED
46e8: 1a000008 bne 4710 <rtems_termios_baud_to_index+0xcc> <== NOT EXECUTED
46ec: e12fff1e bx lr <== NOT EXECUTED
46f0: e3500006 cmp r0, #6 <== NOT EXECUTED
46f4: 012fff1e bxeq lr <== NOT EXECUTED
case B0: baud_index = 0; break;
case B50: baud_index = 1; break;
case B75: baud_index = 2; break;
case B110: baud_index = 3; break;
case B134: baud_index = 4; break;
46f8: b3a00005 movlt r0, #5 <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
46fc: b12fff1e bxlt lr <== NOT EXECUTED
4700: e3500007 cmp r0, #7 <== NOT EXECUTED
4704: 012fff1e bxeq lr <== NOT EXECUTED
4708: e3500008 cmp r0, #8 <== NOT EXECUTED
470c: 012fff1e bxeq lr <== NOT EXECUTED
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
case B57600: baud_index = 16; break;
case B115200: baud_index = 17; break;
case B230400: baud_index = 18; break;
case B460800: baud_index = 19; break;
4710: e3e00000 mvn r0, #0
default: baud_index = -1; break;
}
return baud_index;
}
4714: e12fff1e bx lr
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
4718: e350000f cmp r0, #15 <== NOT EXECUTED
471c: 012fff1e bxeq lr <== NOT EXECUTED
4720: e3a03a01 mov r3, #4096 ; 0x1000 <== NOT EXECUTED
4724: e2833001 add r3, r3, #1 <== NOT EXECUTED
4728: e1500003 cmp r0, r3 <== NOT EXECUTED
472c: 1afffff7 bne 4710 <rtems_termios_baud_to_index+0xcc> <== NOT EXECUTED
case B1800: baud_index = 10; break;
case B2400: baud_index = 11; break;
case B4800: baud_index = 12; break;
case B9600: baud_index = 13; break;
case B19200: baud_index = 14; break;
case B38400: baud_index = 15; break;
4730: e3a00010 mov r0, #16 <== NOT EXECUTED
case B57600: baud_index = 16; break;
4734: e12fff1e bx lr <== NOT EXECUTED
rtems_termios_baud_t termios_baud
)
{
int baud_index;
switch (termios_baud) {
4738: e3500000 cmp r0, #0
473c: 012fff1e bxeq lr
4740: eafffff2 b 4710 <rtems_termios_baud_to_index+0xcc>
00003084 <rtems_termios_bufsize>:
int cbufsize,
int raw_input,
int raw_output
)
{
rtems_termios_cbufsize = cbufsize;
3084: e59f3008 ldr r3, [pc, #8] ; 3094 <rtems_termios_bufsize+0x10><== NOT EXECUTED
3088: e8830007 stm r3, {r0, r1, r2} <== NOT EXECUTED
rtems_termios_raw_input_size = raw_input; rtems_termios_raw_output_size = raw_output; return RTEMS_SUCCESSFUL; }
308c: e3a00000 mov r0, #0 <== NOT EXECUTED
3090: e12fff1e bx lr <== NOT EXECUTED
00004638 <rtems_termios_close>:
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
4638: e92d4070 push {r4, r5, r6, lr}
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
463c: e59f51b0 ldr r5, [pc, #432] ; 47f4 <rtems_termios_close+0x1bc>
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
4640: e5903000 ldr r3, [r0]
rtems_status_code sc;
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4644: e3a01000 mov r1, #0
}
}
rtems_status_code
rtems_termios_close (void *arg)
{
4648: e1a06000 mov r6, r0
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
464c: e1a02001 mov r2, r1
4650: e5950000 ldr r0, [r5]
rtems_status_code
rtems_termios_close (void *arg)
{
rtems_libio_open_close_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
4654: e5934034 ldr r4, [r3, #52] ; 0x34
rtems_status_code sc;
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4658: eb000453 bl 57ac <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
465c: e3500000 cmp r0, #0
4660: 1a00005f bne 47e4 <rtems_termios_close+0x1ac>
rtems_fatal_error_occurred (sc);
if (--tty->refcount == 0) {
4664: e5943008 ldr r3, [r4, #8]
4668: e2433001 sub r3, r3, #1
466c: e3530000 cmp r3, #0
4670: e5843008 str r3, [r4, #8]
4674: 1a00002f bne 4738 <rtems_termios_close+0x100>
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
4678: e59420cc ldr r2, [r4, #204] ; 0xcc
467c: e59f3174 ldr r3, [pc, #372] ; 47f8 <rtems_termios_close+0x1c0>
4680: e0833282 add r3, r3, r2, lsl #5
4684: e5931004 ldr r1, [r3, #4]
4688: e3510000 cmp r1, #0
468c: 0a000040 beq 4794 <rtems_termios_close+0x15c>
/*
* call discipline-specific close
*/
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
4690: e1a00004 mov r0, r4 <== NOT EXECUTED
4694: e1a0e00f mov lr, pc <== NOT EXECUTED
4698: e12fff11 bx r1 <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
}
if (tty->device.outputUsesInterrupts
469c: e59430b4 ldr r3, [r4, #180] ; 0xb4 <== NOT EXECUTED
46a0: e3530002 cmp r3, #2 <== NOT EXECUTED
46a4: 0a000044 beq 47bc <rtems_termios_close+0x184> <== NOT EXECUTED
tty->txTaskId,
TERMIOS_TX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
46a8: e594309c ldr r3, [r4, #156] ; 0x9c
46ac: e3530000 cmp r3, #0
(*tty->device.lastClose)(tty->major, tty->minor, arg);
46b0: 11a02006 movne r2, r6
46b4: 1284000c addne r0, r4, #12
46b8: 18900003 ldmne r0, {r0, r1}
46bc: 11a0e00f movne lr, pc
46c0: 112fff13 bxne r3
if (tty->forw == NULL) {
46c4: e5943000 ldr r3, [r4]
46c8: e3530000 cmp r3, #0
46cc: 0a000020 beq 4754 <rtems_termios_close+0x11c>
if ( rtems_termios_ttyTail != NULL ) {
rtems_termios_ttyTail->forw = NULL;
}
}
else {
tty->forw->back = tty->back;
46d0: e5942004 ldr r2, [r4, #4]
46d4: e5832004 str r2, [r3, #4]
}
if (tty->back == NULL) {
46d8: e5942004 ldr r2, [r4, #4]
46dc: e3520000 cmp r2, #0
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
}
else {
tty->back->forw = tty->forw;
46e0: 15823000 strne r3, [r2]
}
}
else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
46e4: 0a000025 beq 4780 <rtems_termios_close+0x148>
}
}
else {
tty->back->forw = tty->forw;
}
rtems_semaphore_delete (tty->isem);
46e8: e5940014 ldr r0, [r4, #20]
46ec: eb000405 bl 5708 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->osem);
46f0: e5940018 ldr r0, [r4, #24]
46f4: eb000403 bl 5708 <rtems_semaphore_delete>
rtems_semaphore_delete (tty->rawOutBuf.Semaphore);
46f8: e594008c ldr r0, [r4, #140] ; 0x8c
46fc: eb000401 bl 5708 <rtems_semaphore_delete>
if ((tty->device.pollRead == NULL) ||
4700: e59430a0 ldr r3, [r4, #160] ; 0xa0
4704: e3530000 cmp r3, #0
4708: 0a00000e beq 4748 <rtems_termios_close+0x110>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN))
470c: e59430b4 ldr r3, [r4, #180] ; 0xb4
4710: e3530002 cmp r3, #2
4714: 0a00000b beq 4748 <rtems_termios_close+0x110>
rtems_semaphore_delete (tty->rawInBuf.Semaphore);
free (tty->rawInBuf.theBuf);
4718: e5940058 ldr r0, [r4, #88] ; 0x58
471c: ebfff661 bl 20a8 <free>
free (tty->rawOutBuf.theBuf);
4720: e594007c ldr r0, [r4, #124] ; 0x7c
4724: ebfff65f bl 20a8 <free>
free (tty->cbuf);
4728: e594001c ldr r0, [r4, #28]
472c: ebfff65d bl 20a8 <free>
free (tty);
4730: e1a00004 mov r0, r4
4734: ebfff65b bl 20a8 <free>
} rtems_semaphore_release (rtems_termios_ttyMutex);
4738: e5950000 ldr r0, [r5]
473c: eb000462 bl 58cc <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
4740: e3a00000 mov r0, #0
4744: e8bd8070 pop {r4, r5, r6, pc}
rtems_semaphore_delete (tty->isem); rtems_semaphore_delete (tty->osem); rtems_semaphore_delete (tty->rawOutBuf.Semaphore); if ((tty->device.pollRead == NULL) || (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)) rtems_semaphore_delete (tty->rawInBuf.Semaphore);
4748: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
474c: eb0003ed bl 5708 <rtems_semaphore_delete> <== NOT EXECUTED
4750: eafffff0 b 4718 <rtems_termios_close+0xe0> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
4754: e5942004 ldr r2, [r4, #4]
4758: e59f109c ldr r1, [pc, #156] ; 47fc <rtems_termios_close+0x1c4>
if ( rtems_termios_ttyTail != NULL ) {
475c: e3520000 cmp r2, #0
rtems_fatal_error_occurred (sc);
}
if (tty->device.lastClose)
(*tty->device.lastClose)(tty->major, tty->minor, arg);
if (tty->forw == NULL) {
rtems_termios_ttyTail = tty->back;
4760: e5812000 str r2, [r1]
if ( rtems_termios_ttyTail != NULL ) {
4764: 0a00001f beq 47e8 <rtems_termios_close+0x1b0>
rtems_termios_ttyTail->forw = NULL;
4768: e5823000 str r3, [r2] <== NOT EXECUTED
}
}
else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
476c: e5942004 ldr r2, [r4, #4] <== NOT EXECUTED
4770: e5943000 ldr r3, [r4] <== NOT EXECUTED
4774: e3520000 cmp r2, #0 <== NOT EXECUTED
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
}
}
else {
tty->back->forw = tty->forw;
4778: 15823000 strne r3, [r2] <== NOT EXECUTED
}
}
else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
477c: 1affffd9 bne 46e8 <rtems_termios_close+0xb0> <== NOT EXECUTED
rtems_termios_ttyHead = tty->forw;
4780: e59f1078 ldr r1, [pc, #120] ; 4800 <rtems_termios_close+0x1c8>
if ( rtems_termios_ttyHead != NULL ) {
4784: e3530000 cmp r3, #0
}
else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
4788: e5813000 str r3, [r1]
if ( rtems_termios_ttyHead != NULL ) {
rtems_termios_ttyHead->back = NULL;
478c: 15832004 strne r2, [r3, #4]
4790: eaffffd4 b 46e8 <rtems_termios_close+0xb0>
}
else {
/*
* default: just flush output buffer
*/
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4794: e5940018 ldr r0, [r4, #24]
4798: e1a02001 mov r2, r1
479c: eb000402 bl 57ac <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
47a0: e3500000 cmp r0, #0
47a4: 1a00000e bne 47e4 <rtems_termios_close+0x1ac>
rtems_fatal_error_occurred (sc);
}
drainOutput (tty);
47a8: e1a00004 mov r0, r4
47ac: ebfffd9e bl 3e2c <drainOutput>
}
if (tty->device.outputUsesInterrupts
47b0: e59430b4 ldr r3, [r4, #180] ; 0xb4
47b4: e3530002 cmp r3, #2
47b8: 1affffba bne 46a8 <rtems_termios_close+0x70>
== TERMIOS_TASK_DRIVEN) {
/*
* send "terminate" to I/O tasks
*/
sc = rtems_event_send(
47bc: e59400c4 ldr r0, [r4, #196] ; 0xc4 <== NOT EXECUTED
47c0: e3a01001 mov r1, #1 <== NOT EXECUTED
47c4: eb0002d2 bl 5314 <rtems_event_send> <== NOT EXECUTED
tty->rxTaskId,
TERMIOS_RX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
47c8: e3500000 cmp r0, #0 <== NOT EXECUTED
47cc: 1a000004 bne 47e4 <rtems_termios_close+0x1ac> <== NOT EXECUTED
rtems_fatal_error_occurred (sc); sc = rtems_event_send(
47d0: e59400c8 ldr r0, [r4, #200] ; 0xc8 <== NOT EXECUTED
47d4: e3a01001 mov r1, #1 <== NOT EXECUTED
47d8: eb0002cd bl 5314 <rtems_event_send> <== NOT EXECUTED
tty->txTaskId,
TERMIOS_TX_TERMINATE_EVENT);
if (sc != RTEMS_SUCCESSFUL)
47dc: e3500000 cmp r0, #0 <== NOT EXECUTED
47e0: 0affffb0 beq 46a8 <rtems_termios_close+0x70> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
47e4: eb00057d bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
}
else {
tty->forw->back = tty->back;
}
if (tty->back == NULL) {
rtems_termios_ttyHead = tty->forw;
47e8: e59f3010 ldr r3, [pc, #16] ; 4800 <rtems_termios_close+0x1c8>
47ec: e5832000 str r2, [r3]
47f0: eaffffbc b 46e8 <rtems_termios_close+0xb0>
000032a0 <rtems_termios_dequeue_characters>:
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
32a0: e590c090 ldr ip, [r0, #144] ; 0x90 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
32a4: e59020b4 ldr r2, [r0, #180] ; 0xb4 <== NOT EXECUTED
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
32a8: e08c1001 add r1, ip, r1 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
32ac: e3520002 cmp r2, #2 <== NOT EXECUTED
* for each transmitted character.
* It returns number of characters left to transmit
*/
int
rtems_termios_dequeue_characters (void *ttyp, int len)
{
32b0: e52de004 push {lr} ; (str lr, [sp, #-4]!) <== NOT EXECUTED
rtems_status_code sc;
/*
* sum up character count already sent
*/
tty->t_dqlen += len;
32b4: e5801090 str r1, [r0, #144] ; 0x90 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
32b8: 0a00000b beq 32ec <rtems_termios_dequeue_characters+0x4c> <== NOT EXECUTED
TERMIOS_TX_START_EVENT);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
return 0; /* nothing to output in IRQ... */
}
else if (tty->t_line == PPPDISC ) {
32bc: e59030cc ldr r3, [r0, #204] ; 0xcc <== NOT EXECUTED
32c0: e3530005 cmp r3, #5 <== NOT EXECUTED
32c4: 0a000001 beq 32d0 <rtems_termios_dequeue_characters+0x30> <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
else {
return rtems_termios_refill_transmitter(tty);
}
}
32c8: e49de004 pop {lr} ; (ldr lr, [sp], #4) <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
}
return 0; /* nothing to output in IRQ... */
}
else {
return rtems_termios_refill_transmitter(tty);
32cc: eaffff74 b 30a4 <rtems_termios_refill_transmitter> <== NOT EXECUTED
}
else if (tty->t_line == PPPDISC ) {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
32d0: e59f302c ldr r3, [pc, #44] ; 3304 <rtems_termios_dequeue_characters+0x64><== NOT EXECUTED
32d4: e59330b4 ldr r3, [r3, #180] ; 0xb4 <== NOT EXECUTED
32d8: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
32dc: 11a0e00f movne lr, pc <== NOT EXECUTED
32e0: 112fff13 bxne r3 <== NOT EXECUTED
return 0; /* nothing to output in IRQ... */
}
else {
return rtems_termios_refill_transmitter(tty);
}
}
32e4: e3a00000 mov r0, #0 <== NOT EXECUTED
32e8: e49df004 pop {pc} ; (ldr pc, [sp], #4) <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
/*
* send wake up to transmitter task
*/
sc = rtems_event_send(tty->txTaskId,
32ec: e59000c8 ldr r0, [r0, #200] ; 0xc8 <== NOT EXECUTED
32f0: e1a01002 mov r1, r2 <== NOT EXECUTED
32f4: eb000806 bl 5314 <rtems_event_send> <== NOT EXECUTED
TERMIOS_TX_START_EVENT); if (sc != RTEMS_SUCCESSFUL)
32f8: e3500000 cmp r0, #0 <== NOT EXECUTED
32fc: 0afffff8 beq 32e4 <rtems_termios_dequeue_characters+0x44> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
3300: eb000ab6 bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
00003308 <rtems_termios_enqueue_raw_characters>:
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len)
{
3308: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr} <== NOT EXECUTED
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
330c: e59030cc ldr r3, [r0, #204] ; 0xcc <== NOT EXECUTED
3310: e59f82f0 ldr r8, [pc, #752] ; 3608 <rtems_termios_enqueue_raw_characters+0x300><== NOT EXECUTED
3314: e0883283 add r3, r8, r3, lsl #5 <== NOT EXECUTED
3318: e5936010 ldr r6, [r3, #16] <== NOT EXECUTED
331c: e3560000 cmp r6, #0 <== NOT EXECUTED
* device receive interrupt handler.
* Returns the number of characters dropped because of overflow.
*/
int
rtems_termios_enqueue_raw_characters (void *ttyp, char *buf, int len)
{
3320: e24dd00c sub sp, sp, #12 <== NOT EXECUTED
3324: e1a04000 mov r4, r0 <== NOT EXECUTED
3328: e1a05001 mov r5, r1 <== NOT EXECUTED
332c: e1a07002 mov r7, r2 <== NOT EXECUTED
char c;
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
3330: 0a00001e beq 33b0 <rtems_termios_enqueue_raw_characters+0xa8><== NOT EXECUTED
while (len--) {
3334: e3520000 cmp r2, #0 <== NOT EXECUTED
3338: 0a00000b beq 336c <rtems_termios_enqueue_raw_characters+0x64><== NOT EXECUTED
333c: e3a0a000 mov sl, #0 <== NOT EXECUTED
3340: ea000002 b 3350 <rtems_termios_enqueue_raw_characters+0x48><== NOT EXECUTED
3344: e59430cc ldr r3, [r4, #204] ; 0xcc <== NOT EXECUTED
3348: e0883283 add r3, r8, r3, lsl #5 <== NOT EXECUTED
334c: e5936010 ldr r6, [r3, #16] <== NOT EXECUTED
c = *buf++; rtems_termios_linesw[tty->t_line].l_rint(c,tty);
3350: e7d5000a ldrb r0, [r5, sl] <== NOT EXECUTED
3354: e1a01004 mov r1, r4 <== NOT EXECUTED
3358: e28aa001 add sl, sl, #1 <== NOT EXECUTED
335c: e1a0e00f mov lr, pc <== NOT EXECUTED
3360: e12fff16 bx r6 <== NOT EXECUTED
int dropped = 0;
bool flow_rcv = false; /* true, if flow control char received */
rtems_interrupt_level level;
if (rtems_termios_linesw[tty->t_line].l_rint != NULL) {
while (len--) {
3364: e157000a cmp r7, sl <== NOT EXECUTED
3368: 1afffff5 bne 3344 <rtems_termios_enqueue_raw_characters+0x3c><== NOT EXECUTED
}
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
336c: e59490e4 ldr r9, [r4, #228] ; 0xe4 <== NOT EXECUTED
3370: e3590000 cmp r9, #0 <== NOT EXECUTED
3374: 1a00000b bne 33a8 <rtems_termios_enqueue_raw_characters+0xa0><== NOT EXECUTED
3378: e59430dc ldr r3, [r4, #220] ; 0xdc <== NOT EXECUTED
337c: e3530000 cmp r3, #0 <== NOT EXECUTED
3380: 0a000008 beq 33a8 <rtems_termios_enqueue_raw_characters+0xa0><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
3384: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED
3388: e59410e0 ldr r1, [r4, #224] ; 0xe0 <== NOT EXECUTED
338c: e1a0e00f mov lr, pc <== NOT EXECUTED
3390: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
3394: e3a03001 mov r3, #1 <== NOT EXECUTED
3398: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
} } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped; }
339c: e1a00009 mov r0, r9 <== NOT EXECUTED
33a0: e28dd00c add sp, sp, #12 <== NOT EXECUTED
33a4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
} } } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped;
33a8: e3a09000 mov r9, #0 <== NOT EXECUTED
33ac: eafffffa b 339c <rtems_termios_enqueue_raw_characters+0x94><== NOT EXECUTED
if ((tty->flow_ctrl & FL_OSTOP) ||
(tty->rawOutBufState == rob_idle)) {
/* if tx is stopped due to XOFF or out of data */
/* call write function here */
tty->flow_ctrl |= FL_ISNTXOF;
(*tty->device.write)(tty->minor,
33b0: e280304a add r3, r0, #74 ; 0x4a <== NOT EXECUTED
33b4: e58d3008 str r3, [sp, #8] <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
33b8: e2803030 add r3, r0, #48 ; 0x30 <== NOT EXECUTED
33bc: e58d3004 str r3, [sp, #4] <== NOT EXECUTED
33c0: e1a0b006 mov fp, r6 <== NOT EXECUTED
33c4: e58d6000 str r6, [sp] <== NOT EXECUTED
33c8: ea000036 b 34a8 <rtems_termios_enqueue_raw_characters+0x1a0><== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
}
}
else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
33cc: e5940060 ldr r0, [r4, #96] ; 0x60 <== NOT EXECUTED
33d0: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED
33d4: e2800001 add r0, r0, #1 <== NOT EXECUTED
33d8: eb005186 bl 179f8 <__umodsi3> <== NOT EXECUTED
33dc: e1a08000 mov r8, r0 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
33e0: e10f9000 mrs r9, CPSR <== NOT EXECUTED
33e4: e3893080 orr r3, r9, #128 ; 0x80 <== NOT EXECUTED
33e8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* if chars_in_buffer > highwater */ rtems_interrupt_disable(level); if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
33ec: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
33f0: e5940064 ldr r0, [r4, #100] ; 0x64 <== NOT EXECUTED
33f4: e0630000 rsb r0, r3, r0 <== NOT EXECUTED
33f8: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED
33fc: e0800008 add r0, r0, r8 <== NOT EXECUTED
3400: eb00517c bl 179f8 <__umodsi3> <== NOT EXECUTED
% tty->rawInBuf.Size) > tty->highwater) &&
3404: e59430c0 ldr r3, [r4, #192] ; 0xc0 <== NOT EXECUTED
3408: e1500003 cmp r0, r3 <== NOT EXECUTED
340c: 9a000010 bls 3454 <rtems_termios_enqueue_raw_characters+0x14c><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
3410: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
else {
newTail = (tty->rawInBuf.Tail + 1) % tty->rawInBuf.Size;
/* if chars_in_buffer > highwater */
rtems_interrupt_disable(level);
if ((((newTail - tty->rawInBuf.Head + tty->rawInBuf.Size)
3414: e3130001 tst r3, #1 <== NOT EXECUTED
3418: 1a00000d bne 3454 <rtems_termios_enqueue_raw_characters+0x14c><== NOT EXECUTED
% tty->rawInBuf.Size)
> tty->highwater) &&
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
341c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3420: e3833001 orr r3, r3, #1 <== NOT EXECUTED
3424: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
3428: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
342c: e3c33fff bic r3, r3, #1020 ; 0x3fc <== NOT EXECUTED
3430: e3c33001 bic r3, r3, #1 <== NOT EXECUTED
3434: e1a03a83 lsl r3, r3, #21 <== NOT EXECUTED
3438: e1a03aa3 lsr r3, r3, #21 <== NOT EXECUTED
343c: e3530b01 cmp r3, #1024 ; 0x400 <== NOT EXECUTED
3440: 0a000057 beq 35a4 <rtems_termios_enqueue_raw_characters+0x29c><== NOT EXECUTED
(*tty->device.write)(tty->minor, (void *)&(tty->termios.c_cc[VSTOP]), 1); } } else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))
3444: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3448: e2033f41 and r3, r3, #260 ; 0x104 <== NOT EXECUTED
344c: e3530c01 cmp r3, #256 ; 0x100 <== NOT EXECUTED
3450: 0a000062 beq 35e0 <rtems_termios_enqueue_raw_characters+0x2d8><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3454: e129f009 msr CPSR_fc, r9 <== NOT EXECUTED
}
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
3458: e594305c ldr r3, [r4, #92] ; 0x5c <== NOT EXECUTED
345c: e1530008 cmp r3, r8 <== NOT EXECUTED
3460: 0a00002d beq 351c <rtems_termios_enqueue_raw_characters+0x214><== NOT EXECUTED
dropped++;
}
else {
tty->rawInBuf.theBuf[newTail] = c;
3464: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED
3468: e7c3a008 strb sl, [r3, r8] <== NOT EXECUTED
tty->rawInBuf.Tail = newTail;
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
346c: e59430e4 ldr r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
3470: e3530000 cmp r3, #0 <== NOT EXECUTED
if (newTail == tty->rawInBuf.Head) {
dropped++;
}
else {
tty->rawInBuf.theBuf[newTail] = c;
tty->rawInBuf.Tail = newTail;
3474: e5848060 str r8, [r4, #96] ; 0x60 <== NOT EXECUTED
/*
* check to see if rcv wakeup callback was set
*/
if (( !tty->tty_rcvwakeup ) && ( tty->tty_rcv.sw_pfn != NULL )) {
3478: 1a000008 bne 34a0 <rtems_termios_enqueue_raw_characters+0x198><== NOT EXECUTED
347c: e59430dc ldr r3, [r4, #220] ; 0xdc <== NOT EXECUTED
3480: e3530000 cmp r3, #0 <== NOT EXECUTED
3484: 0a000005 beq 34a0 <rtems_termios_enqueue_raw_characters+0x198><== NOT EXECUTED
(*tty->tty_rcv.sw_pfn)(&tty->termios, tty->tty_rcv.sw_arg);
3488: e59d0004 ldr r0, [sp, #4] <== NOT EXECUTED
348c: e59410e0 ldr r1, [r4, #224] ; 0xe0 <== NOT EXECUTED
3490: e1a0e00f mov lr, pc <== NOT EXECUTED
3494: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
3498: e3a03001 mov r3, #1 <== NOT EXECUTED
349c: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
34a0: e2866001 add r6, r6, #1 <== NOT EXECUTED
34a4: e2477001 sub r7, r7, #1 <== NOT EXECUTED
tty->tty_rcvwakeup = 1;
}
return 0;
}
while (len--) {
34a8: e3570000 cmp r7, #0 <== NOT EXECUTED
34ac: 0a00002d beq 3568 <rtems_termios_enqueue_raw_characters+0x260><== NOT EXECUTED
c = *buf++;
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
34b0: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
34b4: e3130c02 tst r3, #512 ; 0x200 <== NOT EXECUTED
}
return 0;
}
while (len--) {
c = *buf++;
34b8: e7d5a006 ldrb sl, [r5, r6] <== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
34bc: 0a000005 beq 34d8 <rtems_termios_enqueue_raw_characters+0x1d0><== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
34c0: e5d4304a ldrb r3, [r4, #74] ; 0x4a <== NOT EXECUTED
34c4: e153000a cmp r3, sl <== NOT EXECUTED
34c8: 0a000017 beq 352c <rtems_termios_enqueue_raw_characters+0x224><== NOT EXECUTED
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
}
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
34cc: e5d43049 ldrb r3, [r4, #73] ; 0x49 <== NOT EXECUTED
34d0: e153000a cmp r3, sl <== NOT EXECUTED
34d4: 0a00001e beq 3554 <rtems_termios_enqueue_raw_characters+0x24c><== NOT EXECUTED
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
flow_rcv = true;
}
}
if (flow_rcv) {
34d8: e35b0000 cmp fp, #0 <== NOT EXECUTED
34dc: 0affffba beq 33cc <rtems_termios_enqueue_raw_characters+0xc4><== NOT EXECUTED
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
34e0: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
34e4: e2033030 and r3, r3, #48 ; 0x30 <== NOT EXECUTED
34e8: e3530020 cmp r3, #32 <== NOT EXECUTED
34ec: 1affffeb bne 34a0 <rtems_termios_enqueue_raw_characters+0x198><== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
34f0: e10f8000 mrs r8, CPSR <== NOT EXECUTED
34f4: e3883080 orr r3, r8, #128 ; 0x80 <== NOT EXECUTED
34f8: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* disable interrupts */ rtems_interrupt_disable(level); tty->flow_ctrl &= ~FL_OSTOP;
34fc: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
3500: e5942094 ldr r2, [r4, #148] ; 0x94 <== NOT EXECUTED
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
3504: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
3508: e3520000 cmp r2, #0 <== NOT EXECUTED
if (flow_rcv) {
/* restart output according to FL_ORCVXOF flag */
if ((tty->flow_ctrl & (FL_ORCVXOF | FL_OSTOP)) == FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
350c: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
3510: 1a00001b bne 3584 <rtems_termios_enqueue_raw_characters+0x27c><== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3514: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
3518: eaffffe0 b 34a0 <rtems_termios_enqueue_raw_characters+0x198><== NOT EXECUTED
}
/* reenable interrupts */
rtems_interrupt_enable(level);
if (newTail == tty->rawInBuf.Head) {
dropped++;
351c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
3520: e2833001 add r3, r3, #1 <== NOT EXECUTED
3524: e58d3000 str r3, [sp] <== NOT EXECUTED
3528: eaffffdc b 34a0 <rtems_termios_enqueue_raw_characters+0x198><== NOT EXECUTED
/* FIXME: implement IXANY: any character restarts output */
/* if incoming XON/XOFF controls outgoing stream: */
if (tty->flow_ctrl & FL_MDXON) {
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
352c: e5d42049 ldrb r2, [r4, #73] ; 0x49 <== NOT EXECUTED
3530: e1520003 cmp r2, r3 <== NOT EXECUTED
/* received VSTOP and VSTART==VSTOP? */ /* then toggle "stop output" status */ tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
3534: 059430b8 ldreq r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
3538: 159430b8 ldrne r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
353c: 02233010 eoreq r3, r3, #16 <== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
3540: 13833010 orrne r3, r3, #16 <== NOT EXECUTED
/* if received char is V_STOP and V_START (both are equal value) */
if (c == tty->termios.c_cc[VSTOP]) {
if (c == tty->termios.c_cc[VSTART]) {
/* received VSTOP and VSTART==VSTOP? */
/* then toggle "stop output" status */
tty->flow_ctrl = tty->flow_ctrl ^ FL_ORCVXOF;
3544: 058430b8 streq r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
}
else {
/* VSTOP received (other code than VSTART) */
/* stop output */
tty->flow_ctrl |= FL_ORCVXOF;
3548: 158430b8 strne r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
} } } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped;
354c: e3a0b001 mov fp, #1 <== NOT EXECUTED
3550: eaffffe2 b 34e0 <rtems_termios_enqueue_raw_characters+0x1d8><== NOT EXECUTED
flow_rcv = true;
}
else if (c == tty->termios.c_cc[VSTART]) {
/* VSTART received */
/* restart output */
tty->flow_ctrl &= ~FL_ORCVXOF;
3554: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
3558: e3c33010 bic r3, r3, #16 <== NOT EXECUTED
355c: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
} } } tty->rawInBufDropped += dropped; rtems_semaphore_release (tty->rawInBuf.Semaphore); return dropped;
3560: e3a0b001 mov fp, #1 <== NOT EXECUTED
3564: eaffffdd b 34e0 <rtems_termios_enqueue_raw_characters+0x1d8><== NOT EXECUTED
tty->tty_rcvwakeup = 1; } } } } tty->rawInBufDropped += dropped;
3568: e5943078 ldr r3, [r4, #120] ; 0x78 <== NOT EXECUTED
356c: e59d9000 ldr r9, [sp] <== NOT EXECUTED
3570: e0833009 add r3, r3, r9 <== NOT EXECUTED
3574: e5843078 str r3, [r4, #120] ; 0x78 <== NOT EXECUTED
rtems_semaphore_release (tty->rawInBuf.Semaphore);
3578: e5940068 ldr r0, [r4, #104] ; 0x68 <== NOT EXECUTED
357c: eb0008d2 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
return dropped;
3580: eaffff85 b 339c <rtems_termios_enqueue_raw_characters+0x94><== NOT EXECUTED
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail], 1);
3584: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
3588: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED
358c: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
3590: e0811003 add r1, r1, r3 <== NOT EXECUTED
3594: e3a02001 mov r2, #1 <== NOT EXECUTED
3598: e1a0e00f mov lr, pc <== NOT EXECUTED
359c: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
35a0: eaffffdb b 3514 <rtems_termios_enqueue_raw_characters+0x20c><== NOT EXECUTED
!(tty->flow_ctrl & FL_IREQXOF)) {
/* incoming data stream should be stopped */
tty->flow_ctrl |= FL_IREQXOF;
if ((tty->flow_ctrl & (FL_MDXOF | FL_ISNTXOF))
== (FL_MDXOF ) ){
if ((tty->flow_ctrl & FL_OSTOP) ||
35a4: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
35a8: e3130020 tst r3, #32 <== NOT EXECUTED
35ac: 1a000002 bne 35bc <rtems_termios_enqueue_raw_characters+0x2b4><== NOT EXECUTED
(tty->rawOutBufState == rob_idle)) {
35b0: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
35b4: e3530000 cmp r3, #0 <== NOT EXECUTED
35b8: 1affffa5 bne 3454 <rtems_termios_enqueue_raw_characters+0x14c><== NOT EXECUTED
/* if tx is stopped due to XOFF or out of data */ /* call write function here */ tty->flow_ctrl |= FL_ISNTXOF;
35bc: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
35c0: e3833002 orr r3, r3, #2 <== NOT EXECUTED
35c4: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
35c8: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
35cc: e59d1008 ldr r1, [sp, #8] <== NOT EXECUTED
35d0: e3a02001 mov r2, #1 <== NOT EXECUTED
35d4: e1a0e00f mov lr, pc <== NOT EXECUTED
35d8: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
35dc: eaffff9c b 3454 <rtems_termios_enqueue_raw_characters+0x14c><== NOT EXECUTED
1);
}
}
else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))
== (FL_MDRTS ) ) {
tty->flow_ctrl |= FL_IRTSOFF;
35e0: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
35e4: e59430ac ldr r3, [r4, #172] ; 0xac <== NOT EXECUTED
1);
}
}
else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))
== (FL_MDRTS ) ) {
tty->flow_ctrl |= FL_IRTSOFF;
35e8: e3822004 orr r2, r2, #4 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
35ec: e3530000 cmp r3, #0 <== NOT EXECUTED
1);
}
}
else if ((tty->flow_ctrl & (FL_MDRTS | FL_IRTSOFF))
== (FL_MDRTS ) ) {
tty->flow_ctrl |= FL_IRTSOFF;
35f0: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* deactivate RTS line */
if (tty->device.stopRemoteTx != NULL) {
35f4: 0affff96 beq 3454 <rtems_termios_enqueue_raw_characters+0x14c><== NOT EXECUTED
tty->device.stopRemoteTx(tty->minor);
35f8: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
35fc: e1a0e00f mov lr, pc <== NOT EXECUTED
3600: e12fff13 bx r3 <== NOT EXECUTED
3604: eaffff92 b 3454 <rtems_termios_enqueue_raw_characters+0x14c><== NOT EXECUTED
0000303c <rtems_termios_initialize>:
struct rtems_termios_tty *rtems_termios_ttyTail;
rtems_id rtems_termios_ttyMutex;
void
rtems_termios_initialize (void)
{
303c: e52de004 push {lr} ; (str lr, [sp, #-4]!)
rtems_status_code sc;
/*
* Create the mutex semaphore for the tty list
*/
if (!rtems_termios_ttyMutex) {
3040: e59fc034 ldr ip, [pc, #52] ; 307c <rtems_termios_initialize+0x40>
3044: e59c3000 ldr r3, [ip]
3048: e3530000 cmp r3, #0
struct rtems_termios_tty *rtems_termios_ttyTail;
rtems_id rtems_termios_ttyMutex;
void
rtems_termios_initialize (void)
{
304c: e24dd004 sub sp, sp, #4
rtems_status_code sc;
/*
* Create the mutex semaphore for the tty list
*/
if (!rtems_termios_ttyMutex) {
3050: 0a000001 beq 305c <rtems_termios_initialize+0x20>
RTEMS_NO_PRIORITY,
&rtems_termios_ttyMutex);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
3054: e28dd004 add sp, sp, #4
3058: e8bd8000 pop {pc}
/*
* Create the mutex semaphore for the tty list
*/
if (!rtems_termios_ttyMutex) {
sc = rtems_semaphore_create (
305c: e59f001c ldr r0, [pc, #28] ; 3080 <rtems_termios_initialize+0x44>
3060: e3a01001 mov r1, #1
3064: e3a02054 mov r2, #84 ; 0x54
3068: e58dc000 str ip, [sp]
306c: eb000933 bl 5540 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'm', 'i'),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&rtems_termios_ttyMutex);
if (sc != RTEMS_SUCCESSFUL)
3070: e3500000 cmp r0, #0
3074: 0afffff6 beq 3054 <rtems_termios_initialize+0x18>
rtems_fatal_error_occurred (sc);
3078: eb000b58 bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
00004258 <rtems_termios_ioctl>:
rtems_status_code
rtems_termios_ioctl (void *arg)
{
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
4258: e5903000 ldr r3, [r0]
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
425c: e3a01000 mov r1, #0
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
4260: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
4264: e580100c str r1, [r0, #12]
rtems_status_code
rtems_termios_ioctl (void *arg)
{
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
4268: e5935034 ldr r5, [r3, #52] ; 0x34
}
}
rtems_status_code
rtems_termios_ioctl (void *arg)
{
426c: e1a04000 mov r4, r0
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
4270: e1a02001 mov r2, r1
4274: e5950018 ldr r0, [r5, #24]
rtems_status_code
rtems_termios_ioctl (void *arg)
{
rtems_libio_ioctl_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
struct ttywakeup *wakeup = (struct ttywakeup *)args->buffer;
4278: e5947008 ldr r7, [r4, #8]
rtems_status_code sc;
args->ioctl_return = 0;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
427c: eb00054a bl 57ac <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL) {
4280: e2506000 subs r6, r0, #0
4284: 1a00000e bne 42c4 <rtems_termios_ioctl+0x6c>
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
4288: e5943004 ldr r3, [r4, #4]
428c: e3530004 cmp r3, #4
4290: 0a000006 beq 42b0 <rtems_termios_ioctl+0x58>
4294: 8a00000d bhi 42d0 <rtems_termios_ioctl+0x78>
4298: e3530002 cmp r3, #2
429c: 0a000020 beq 4324 <rtems_termios_ioctl+0xcc>
42a0: 9a000087 bls 44c4 <rtems_termios_ioctl+0x26c>
if (tty->device.setAttributes)
(*tty->device.setAttributes)(tty->minor, &tty->termios);
break;
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
42a4: e1a00005 mov r0, r5
42a8: ebfffedf bl 3e2c <drainOutput>
break;
42ac: ea000002 b 42bc <rtems_termios_ioctl+0x64>
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
break;
case RTEMS_IO_RCVWAKEUP:
tty->tty_rcv = *wakeup;
42b0: e897000c ldm r7, {r2, r3} <== NOT EXECUTED
42b4: e58520dc str r2, [r5, #220] ; 0xdc <== NOT EXECUTED
42b8: e58530e0 str r3, [r5, #224] ; 0xe0 <== NOT EXECUTED
/* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc; } break; } rtems_semaphore_release (tty->osem);
42bc: e5950018 ldr r0, [r5, #24]
42c0: eb000581 bl 58cc <rtems_semaphore_release>
args->ioctl_return = sc;
42c4: e584600c str r6, [r4, #12]
return sc; }
42c8: e1a00006 mov r0, r6
42cc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
42d0: e3a02a46 mov r2, #286720 ; 0x46000 <== NOT EXECUTED
42d4: e2822e67 add r2, r2, #1648 ; 0x670 <== NOT EXECUTED
42d8: e282213d add r2, r2, #1073741839 ; 0x4000000f <== NOT EXECUTED
42dc: e1530002 cmp r3, r2 <== NOT EXECUTED
42e0: 0a00006b beq 4494 <rtems_termios_ioctl+0x23c> <== NOT EXECUTED
42e4: 8a000082 bhi 44f4 <rtems_termios_ioctl+0x29c> <== NOT EXECUTED
42e8: e3530005 cmp r3, #5 <== NOT EXECUTED
42ec: 0a0000a5 beq 4588 <rtems_termios_ioctl+0x330> <== NOT EXECUTED
default:
if (rtems_termios_linesw[tty->t_line].l_ioctl != NULL) {
42f0: e59520cc ldr r2, [r5, #204] ; 0xcc <== NOT EXECUTED
42f4: e59f3334 ldr r3, [pc, #820] ; 4630 <rtems_termios_ioctl+0x3d8><== NOT EXECUTED
42f8: e0833282 add r3, r3, r2, lsl #5 <== NOT EXECUTED
42fc: e5933018 ldr r3, [r3, #24] <== NOT EXECUTED
4300: e3530000 cmp r3, #0 <== NOT EXECUTED
4304: 03a0600a moveq r6, #10 <== NOT EXECUTED
4308: 0affffeb beq 42bc <rtems_termios_ioctl+0x64> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_ioctl(tty,args);
430c: e1a00005 mov r0, r5 <== NOT EXECUTED
4310: e1a01004 mov r1, r4 <== NOT EXECUTED
4314: e1a0e00f mov lr, pc <== NOT EXECUTED
4318: e12fff13 bx r3 <== NOT EXECUTED
431c: e1a06000 mov r6, r0 <== NOT EXECUTED
4320: eaffffe5 b 42bc <rtems_termios_ioctl+0x64> <== NOT EXECUTED
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
4324: e594e008 ldr lr, [r4, #8]
4328: e2857030 add r7, r5, #48 ; 0x30
432c: e8be000f ldm lr!, {r0, r1, r2, r3}
4330: e1a0c007 mov ip, r7
4334: e8ac000f stmia ip!, {r0, r1, r2, r3}
4338: e8be000f ldm lr!, {r0, r1, r2, r3}
433c: e8ac000f stmia ip!, {r0, r1, r2, r3}
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
4340: e59520b8 ldr r2, [r5, #184] ; 0xb8
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
4344: e59e3000 ldr r3, [lr]
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
4348: e3120c02 tst r2, #512 ; 0x200
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
break;
case RTEMS_IO_SET_ATTRIBUTES:
tty->termios = *(struct termios *)args->buffer;
434c: e58c3000 str r3, [ip]
/*
* check for flow control options to be switched off
*/
/* check for outgoing XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXON) &&
4350: 0a000012 beq 43a0 <rtems_termios_ioctl+0x148>
4354: e5953030 ldr r3, [r5, #48] ; 0x30
4358: e3130b01 tst r3, #1024 ; 0x400
435c: 1a00000f bne 43a0 <rtems_termios_ioctl+0x148>
!(tty->termios.c_iflag & IXON)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXON | FL_ORCVXOF);
4360: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
4364: e3c33e21 bic r3, r3, #528 ; 0x210 <== NOT EXECUTED
4368: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
436c: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
4370: e3130020 tst r3, #32 <== NOT EXECUTED
4374: 0a000009 beq 43a0 <rtems_termios_ioctl+0x148> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
4378: e10f8000 mrs r8, CPSR <== NOT EXECUTED
437c: e3883080 orr r3, r8, #128 ; 0x80 <== NOT EXECUTED
4380: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
4384: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
4388: e5952094 ldr r2, [r5, #148] ; 0x94 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
438c: e3c33020 bic r3, r3, #32 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
4390: e3520000 cmp r2, #0 <== NOT EXECUTED
/* has output been stopped due to received XOFF? */
if (tty->flow_ctrl & FL_OSTOP) {
/* disable interrupts */
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
4394: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
4398: 1a00009c bne 4610 <rtems_termios_ioctl+0x3b8> <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
439c: e129f008 msr CPSR_fc, r8 <== NOT EXECUTED
/* reenable interrupts */
rtems_interrupt_enable(level);
}
}
/* check for incoming XON/XOFF flow control switched off */
if (( tty->flow_ctrl & FL_MDXOF) &&
43a0: e59530b8 ldr r3, [r5, #184] ; 0xb8
43a4: e3130b01 tst r3, #1024 ; 0x400
43a8: 0a000008 beq 43d0 <rtems_termios_ioctl+0x178>
43ac: e5953030 ldr r3, [r5, #48] ; 0x30 <== NOT EXECUTED
43b0: e3130a01 tst r3, #4096 ; 0x1000 <== NOT EXECUTED
43b4: 1a000005 bne 43d0 <rtems_termios_ioctl+0x178> <== NOT EXECUTED
!(tty->termios.c_iflag & IXOFF)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDXOF);
43b8: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
43bc: e3c33b01 bic r3, r3, #1024 ; 0x400 <== NOT EXECUTED
43c0: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* FIXME: what happens, if we had sent XOFF but not yet XON? */
tty->flow_ctrl &= ~(FL_ISNTXOF);
43c4: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
43c8: e3c33002 bic r3, r3, #2 <== NOT EXECUTED
43cc: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
}
/* check for incoming RTS/CTS flow control switched off */
if (( tty->flow_ctrl & FL_MDRTS) &&
43d0: e59530b8 ldr r3, [r5, #184] ; 0xb8
43d4: e3130c01 tst r3, #256 ; 0x100
43d8: 05952038 ldreq r2, [r5, #56] ; 0x38
43dc: 0a000012 beq 442c <rtems_termios_ioctl+0x1d4>
43e0: e5952038 ldr r2, [r5, #56] ; 0x38 <== NOT EXECUTED
43e4: e3520000 cmp r2, #0 <== NOT EXECUTED
43e8: ba00007c blt 45e0 <rtems_termios_ioctl+0x388> <== NOT EXECUTED
!(tty->termios.c_cflag & CRTSCTS)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
43ec: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
43f0: e3c33c01 bic r3, r3, #256 ; 0x100 <== NOT EXECUTED
43f4: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) &&
43f8: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
43fc: e3130004 tst r3, #4 <== NOT EXECUTED
4400: 0a000006 beq 4420 <rtems_termios_ioctl+0x1c8> <== NOT EXECUTED
(tty->device.startRemoteTx != NULL)) {
4404: e59530b0 ldr r3, [r5, #176] ; 0xb0 <== NOT EXECUTED
!(tty->termios.c_cflag & CRTSCTS)) {
/* clear related flags in flow_ctrl */
tty->flow_ctrl &= ~(FL_MDRTS);
/* restart remote Tx, if it was stopped */
if ((tty->flow_ctrl & FL_IRTSOFF) &&
4408: e3530000 cmp r3, #0 <== NOT EXECUTED
440c: 0a000003 beq 4420 <rtems_termios_ioctl+0x1c8> <== NOT EXECUTED
(tty->device.startRemoteTx != NULL)) {
tty->device.startRemoteTx(tty->minor);
4410: e5950010 ldr r0, [r5, #16] <== NOT EXECUTED
4414: e1a0e00f mov lr, pc <== NOT EXECUTED
4418: e12fff13 bx r3 <== NOT EXECUTED
441c: e5952038 ldr r2, [r5, #56] ; 0x38 <== NOT EXECUTED
}
tty->flow_ctrl &= ~(FL_IRTSOFF);
4420: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
4424: e3c33004 bic r3, r3, #4 <== NOT EXECUTED
4428: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
442c: e3520000 cmp r2, #0
4430: ba00006a blt 45e0 <rtems_termios_ioctl+0x388>
tty->flow_ctrl |= FL_MDRTS;
}
/* check for incoming XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXOFF) {
4434: e5953030 ldr r3, [r5, #48] ; 0x30
4438: e3130a01 tst r3, #4096 ; 0x1000
tty->flow_ctrl |= FL_MDXOF;
443c: 159520b8 ldrne r2, [r5, #184] ; 0xb8
4440: 13822b01 orrne r2, r2, #1024 ; 0x400
4444: 158520b8 strne r2, [r5, #184] ; 0xb8
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
4448: e3130b01 tst r3, #1024 ; 0x400
tty->flow_ctrl |= FL_MDXON;
444c: 159530b8 ldrne r3, [r5, #184] ; 0xb8
tty->termios = *(struct termios *)args->buffer;
/* check for and process change in flow control options */
termios_set_flowctrl(tty);
if (tty->termios.c_lflag & ICANON) {
4450: e595803c ldr r8, [r5, #60] ; 0x3c
if (tty->termios.c_iflag & IXOFF) {
tty->flow_ctrl |= FL_MDXOF;
}
/* check for outgoing XON/XOF flow control switched on */
if (tty->termios.c_iflag & IXON) {
tty->flow_ctrl |= FL_MDXON;
4454: 13833c02 orrne r3, r3, #512 ; 0x200
4458: 158530b8 strne r3, [r5, #184] ; 0xb8
tty->termios = *(struct termios *)args->buffer;
/* check for and process change in flow control options */
termios_set_flowctrl(tty);
if (tty->termios.c_lflag & ICANON) {
445c: e2188002 ands r8, r8, #2
4460: 0a00004c beq 4598 <rtems_termios_ioctl+0x340>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
4464: e3a03000 mov r3, #0
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT; tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
4468: e5853074 str r3, [r5, #116] ; 0x74
/* check for and process change in flow control options */
termios_set_flowctrl(tty);
if (tty->termios.c_lflag & ICANON) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
446c: e585306c str r3, [r5, #108] ; 0x6c
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
4470: e5853070 str r3, [r5, #112] ; 0x70
else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
}
}
}
if (tty->device.setAttributes)
4474: e59530a8 ldr r3, [r5, #168] ; 0xa8
4478: e3530000 cmp r3, #0
447c: 0affff8e beq 42bc <rtems_termios_ioctl+0x64>
(*tty->device.setAttributes)(tty->minor, &tty->termios);
4480: e1a01007 mov r1, r7
4484: e5950010 ldr r0, [r5, #16]
4488: e1a0e00f mov lr, pc
448c: e12fff13 bx r3
4490: eaffff89 b 42bc <rtems_termios_ioctl+0x64>
*(int*)(args->buffer)=tty->t_line;
break;
#endif
case FIONREAD:
{
int rawnc = tty->rawInBuf.Tail - tty->rawInBuf.Head;
4494: e5952060 ldr r2, [r5, #96] ; 0x60 <== NOT EXECUTED
4498: e595305c ldr r3, [r5, #92] ; 0x5c <== NOT EXECUTED
if ( rawnc < 0 )
449c: e0523003 subs r3, r2, r3 <== NOT EXECUTED
rawnc += tty->rawInBuf.Size;
44a0: 45952064 ldrmi r2, [r5, #100] ; 0x64 <== NOT EXECUTED
44a4: 40833002 addmi r3, r3, r2 <== NOT EXECUTED
/* Half guess that this is the right operation */ *(int *)args->buffer = tty->ccount - tty->cindex + rawnc;
44a8: e2851020 add r1, r5, #32 <== NOT EXECUTED
44ac: e8910006 ldm r1, {r1, r2} <== NOT EXECUTED
44b0: e0412002 sub r2, r1, r2 <== NOT EXECUTED
44b4: e5941008 ldr r1, [r4, #8] <== NOT EXECUTED
44b8: e0823003 add r3, r2, r3 <== NOT EXECUTED
44bc: e5813000 str r3, [r1] <== NOT EXECUTED
44c0: eaffff7d b 42bc <rtems_termios_ioctl+0x64> <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
44c4: e3530001 cmp r3, #1
44c8: 1affff88 bne 42f0 <rtems_termios_ioctl+0x98>
sc = RTEMS_INVALID_NUMBER;
}
break;
case RTEMS_IO_GET_ATTRIBUTES:
*(struct termios *)args->buffer = tty->termios;
44cc: e5947008 ldr r7, [r4, #8]
44d0: e285c030 add ip, r5, #48 ; 0x30
44d4: e8bc000f ldm ip!, {r0, r1, r2, r3}
44d8: e1a0e007 mov lr, r7
44dc: e8ae000f stmia lr!, {r0, r1, r2, r3}
44e0: e8bc000f ldm ip!, {r0, r1, r2, r3}
44e4: e8ae000f stmia lr!, {r0, r1, r2, r3}
44e8: e59c3000 ldr r3, [ip]
44ec: e58e3000 str r3, [lr]
break;
44f0: eaffff71 b 42bc <rtems_termios_ioctl+0x64>
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL) {
args->ioctl_return = sc;
return sc;
}
switch (args->command) {
44f4: e3a02a47 mov r2, #290816 ; 0x47000 <== NOT EXECUTED
44f8: e2822e41 add r2, r2, #1040 ; 0x410 <== NOT EXECUTED
44fc: e2822129 add r2, r2, #1073741834 ; 0x4000000a <== NOT EXECUTED
4500: e1530002 cmp r3, r2 <== NOT EXECUTED
4504: 0a00001b beq 4578 <rtems_termios_ioctl+0x320> <== NOT EXECUTED
4508: e3a02a47 mov r2, #290816 ; 0x47000 <== NOT EXECUTED
450c: e2822e41 add r2, r2, #1040 ; 0x410 <== NOT EXECUTED
4510: e282212e add r2, r2, #-2147483637 ; 0x8000000b <== NOT EXECUTED
4514: e1530002 cmp r3, r2 <== NOT EXECUTED
4518: 1affff74 bne 42f0 <rtems_termios_ioctl+0x98> <== NOT EXECUTED
#if 1 /* FIXME */
case TIOCSETD:
/*
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
451c: e59f710c ldr r7, [pc, #268] ; 4630 <rtems_termios_ioctl+0x3d8><== NOT EXECUTED
4520: e59530cc ldr r3, [r5, #204] ; 0xcc <== NOT EXECUTED
4524: e0873283 add r3, r7, r3, lsl #5 <== NOT EXECUTED
4528: e5933004 ldr r3, [r3, #4] <== NOT EXECUTED
452c: e3530000 cmp r3, #0 <== NOT EXECUTED
4530: 0a000003 beq 4544 <rtems_termios_ioctl+0x2ec> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
4534: e1a00005 mov r0, r5 <== NOT EXECUTED
4538: e1a0e00f mov lr, pc <== NOT EXECUTED
453c: e12fff13 bx r3 <== NOT EXECUTED
4540: e1a06000 mov r6, r0 <== NOT EXECUTED
} tty->t_line=*(int*)(args->buffer);
4544: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
4548: e5932000 ldr r2, [r3] <== NOT EXECUTED
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
454c: e7973282 ldr r3, [r7, r2, lsl #5] <== NOT EXECUTED
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
tty->t_sc = NULL; /* ensure that no more valid data */
4550: e3a01000 mov r1, #0 <== NOT EXECUTED
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
4554: e3530000 cmp r3, #0 <== NOT EXECUTED
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
tty->t_sc = NULL; /* ensure that no more valid data */
4558: e58510d0 str r1, [r5, #208] ; 0xd0 <== NOT EXECUTED
* close old line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_close != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_close(tty);
}
tty->t_line=*(int*)(args->buffer);
455c: e58520cc str r2, [r5, #204] ; 0xcc <== NOT EXECUTED
tty->t_sc = NULL; /* ensure that no more valid data */
/*
* open new line discipline
*/
if (rtems_termios_linesw[tty->t_line].l_open != NULL) {
4560: 0affff55 beq 42bc <rtems_termios_ioctl+0x64> <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_open(tty);
4564: e1a00005 mov r0, r5 <== NOT EXECUTED
4568: e1a0e00f mov lr, pc <== NOT EXECUTED
456c: e12fff13 bx r3 <== NOT EXECUTED
4570: e1a06000 mov r6, r0 <== NOT EXECUTED
4574: eaffff50 b 42bc <rtems_termios_ioctl+0x64> <== NOT EXECUTED
} break; case TIOCGETD: *(int*)(args->buffer)=tty->t_line;
4578: e5943008 ldr r3, [r4, #8] <== NOT EXECUTED
457c: e59520cc ldr r2, [r5, #204] ; 0xcc <== NOT EXECUTED
4580: e5832000 str r2, [r3] <== NOT EXECUTED
break;
4584: eaffff4c b 42bc <rtems_termios_ioctl+0x64> <== NOT EXECUTED
case RTEMS_IO_TCDRAIN:
drainOutput (tty);
break;
case RTEMS_IO_SNDWAKEUP:
tty->tty_snd = *wakeup;
4588: e897000c ldm r7, {r2, r3} <== NOT EXECUTED
458c: e58520d4 str r2, [r5, #212] ; 0xd4 <== NOT EXECUTED
4590: e58530d8 str r3, [r5, #216] ; 0xd8 <== NOT EXECUTED
break;
4594: eaffff48 b 42bc <rtems_termios_ioctl+0x64> <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
}
else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
4598: e5d5a046 ldrb sl, [r5, #70] ; 0x46
459c: eb0002d6 bl 50fc <rtems_clock_get_ticks_per_second>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
}
else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
45a0: e000009a mul r0, sl, r0
45a4: e59f2088 ldr r2, [pc, #136] ; 4634 <rtems_termios_ioctl+0x3dc>
45a8: e0831092 umull r1, r3, r2, r0
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
45ac: e5d52046 ldrb r2, [r5, #70] ; 0x46
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
}
else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
45b0: e1a031a3 lsr r3, r3, #3
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
45b4: e3520000 cmp r2, #0
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
}
else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
45b8: e5853054 str r3, [r5, #84] ; 0x54
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
45bc: 0a00000b beq 45f0 <rtems_termios_ioctl+0x398>
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
if (tty->termios.c_cc[VMIN])
45c0: e5d52047 ldrb r2, [r5, #71] ; 0x47 <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
45c4: e3520000 cmp r2, #0 <== NOT EXECUTED
45c8: 01a02003 moveq r2, r3 <== NOT EXECUTED
45cc: 13a02000 movne r2, #0 <== NOT EXECUTED
}
else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
45d0: e585806c str r8, [r5, #108] ; 0x6c <== NOT EXECUTED
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks; if (tty->termios.c_cc[VMIN]) tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
45d4: e5852074 str r2, [r5, #116] ; 0x74 <== NOT EXECUTED
else {
tty->vtimeTicks = tty->termios.c_cc[VTIME] *
rtems_clock_get_ticks_per_second() / 10;
if (tty->termios.c_cc[VTIME]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = tty->vtimeTicks;
45d8: e5853070 str r3, [r5, #112] ; 0x70 <== NOT EXECUTED
45dc: eaffffa4 b 4474 <rtems_termios_ioctl+0x21c> <== NOT EXECUTED
/*
* check for flow control options to be switched on
*/
/* check for incoming RTS/CTS flow control switched on */
if (tty->termios.c_cflag & CRTSCTS) {
tty->flow_ctrl |= FL_MDRTS;
45e0: e59530b8 ldr r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
45e4: e3833c01 orr r3, r3, #256 ; 0x100 <== NOT EXECUTED
45e8: e58530b8 str r3, [r5, #184] ; 0xb8 <== NOT EXECUTED
45ec: eaffff90 b 4434 <rtems_termios_ioctl+0x1dc> <== NOT EXECUTED
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
}
else {
if (tty->termios.c_cc[VMIN]) {
45f0: e5d53047 ldrb r3, [r5, #71] ; 0x47
45f4: e3530000 cmp r3, #0
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
}
else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
45f8: 03a03001 moveq r3, #1
}
else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
45fc: 15852074 strne r2, [r5, #116] ; 0x74
else
tty->rawInBufSemaphoreFirstTimeout = tty->vtimeTicks;
}
else {
if (tty->termios.c_cc[VMIN]) {
tty->rawInBufSemaphoreOptions = RTEMS_WAIT;
4600: 1585206c strne r2, [r5, #108] ; 0x6c
tty->rawInBufSemaphoreTimeout = RTEMS_NO_TIMEOUT;
4604: 15852070 strne r2, [r5, #112] ; 0x70
tty->rawInBufSemaphoreFirstTimeout = RTEMS_NO_TIMEOUT;
}
else {
tty->rawInBufSemaphoreOptions = RTEMS_NO_WAIT;
4608: 0585306c streq r3, [r5, #108] ; 0x6c
460c: eaffff98 b 4474 <rtems_termios_ioctl+0x21c>
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
4610: e5953084 ldr r3, [r5, #132] ; 0x84 <== NOT EXECUTED
rtems_interrupt_disable(level);
tty->flow_ctrl &= ~FL_OSTOP;
/* check for chars in output buffer (or rob_state?) */
if (tty->rawOutBufState != rob_idle) {
/* if chars available, call write function... */
(*tty->device.write)(tty->minor,
4614: e595107c ldr r1, [r5, #124] ; 0x7c <== NOT EXECUTED
4618: e5950010 ldr r0, [r5, #16] <== NOT EXECUTED
461c: e0811003 add r1, r1, r3 <== NOT EXECUTED
4620: e3a02001 mov r2, #1 <== NOT EXECUTED
4624: e1a0e00f mov lr, pc <== NOT EXECUTED
4628: e595f0a4 ldr pc, [r5, #164] ; 0xa4 <== NOT EXECUTED
462c: eaffff5a b 439c <rtems_termios_ioctl+0x144> <== NOT EXECUTED
00004804 <rtems_termios_open>:
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
4804: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
4808: e59f7490 ldr r7, [pc, #1168] ; 4ca0 <rtems_termios_open+0x49c>
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
480c: e1a06001 mov r6, r1
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
4810: e3a01000 mov r1, #0
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
4814: e24dd014 sub sp, sp, #20
4818: e1a05000 mov r5, r0
481c: e1a08002 mov r8, r2
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
4820: e5970000 ldr r0, [r7]
4824: e1a02001 mov r2, r1
rtems_device_major_number major,
rtems_device_minor_number minor,
void *arg,
const rtems_termios_callbacks *callbacks
)
{
4828: e1a09003 mov r9, r3
struct rtems_termios_tty *tty;
/*
* See if the device has already been opened
*/
sc = rtems_semaphore_obtain (rtems_termios_ttyMutex,
482c: eb0003de bl 57ac <rtems_semaphore_obtain>
RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL)
4830: e250a000 subs sl, r0, #0
4834: 1a000020 bne 48bc <rtems_termios_open+0xb8>
return sc;
for (tty = rtems_termios_ttyHead ; tty != NULL ; tty = tty->forw) {
4838: e59fb464 ldr fp, [pc, #1124] ; 4ca4 <rtems_termios_open+0x4a0>
483c: e59b4000 ldr r4, [fp]
4840: e3540000 cmp r4, #0
4844: 1a000003 bne 4858 <rtems_termios_open+0x54>
4848: ea00002b b 48fc <rtems_termios_open+0xf8>
484c: e5944000 ldr r4, [r4]
4850: e3540000 cmp r4, #0
4854: 0a000028 beq 48fc <rtems_termios_open+0xf8>
if ((tty->major == major) && (tty->minor == minor))
4858: e594300c ldr r3, [r4, #12]
485c: e1530005 cmp r3, r5
4860: 1afffff9 bne 484c <rtems_termios_open+0x48>
4864: e5943010 ldr r3, [r4, #16]
4868: e1530006 cmp r3, r6
486c: 1afffff6 bne 484c <rtems_termios_open+0x48>
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
if (!tty->refcount++) {
4870: e5943008 ldr r3, [r4, #8]
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
4874: e5982000 ldr r2, [r8]
if (!tty->refcount++) {
4878: e3530000 cmp r3, #0
487c: e2833001 add r3, r3, #1
*/
if (c++ == 'z')
c = 'a';
}
args->iop->data1 = tty;
4880: e5824034 str r4, [r2, #52] ; 0x34
if (!tty->refcount++) {
4884: e5843008 str r3, [r4, #8]
4888: 1a000009 bne 48b4 <rtems_termios_open+0xb0>
if (tty->device.firstOpen)
488c: e5943098 ldr r3, [r4, #152] ; 0x98
4890: e3530000 cmp r3, #0
(*tty->device.firstOpen)(major, minor, arg);
4894: 11a00005 movne r0, r5
4898: 11a01006 movne r1, r6
489c: 11a02008 movne r2, r8
48a0: 11a0e00f movne lr, pc
48a4: 112fff13 bxne r3
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
48a8: e59430b4 ldr r3, [r4, #180] ; 0xb4
48ac: e3530002 cmp r3, #2
48b0: 0a000004 beq 48c8 <rtems_termios_open+0xc4>
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
}
rtems_semaphore_release (rtems_termios_ttyMutex);
48b4: e5970000 ldr r0, [r7]
48b8: eb000403 bl 58cc <rtems_semaphore_release>
return RTEMS_SUCCESSFUL; }
48bc: e1a0000a mov r0, sl
48c0: e28dd014 add sp, sp, #20
48c4: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
(*tty->device.firstOpen)(major, minor, arg);
/*
* start I/O tasks, if needed
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_start(tty->rxTaskId,
48c8: e59400c4 ldr r0, [r4, #196] ; 0xc4 <== NOT EXECUTED
48cc: e59f13d4 ldr r1, [pc, #980] ; 4ca8 <rtems_termios_open+0x4a4><== NOT EXECUTED
48d0: e1a02004 mov r2, r4 <== NOT EXECUTED
48d4: eb0004cd bl 5c10 <rtems_task_start> <== NOT EXECUTED
rtems_termios_rxdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL)
48d8: e3500000 cmp r0, #0 <== NOT EXECUTED
48dc: 1a0000d2 bne 4c2c <rtems_termios_open+0x428> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
sc = rtems_task_start(tty->txTaskId,
48e0: e1a02004 mov r2, r4 <== NOT EXECUTED
48e4: e59400c8 ldr r0, [r4, #200] ; 0xc8 <== NOT EXECUTED
48e8: e59f13bc ldr r1, [pc, #956] ; 4cac <rtems_termios_open+0x4a8><== NOT EXECUTED
48ec: eb0004c7 bl 5c10 <rtems_task_start> <== NOT EXECUTED
rtems_termios_txdaemon, (rtems_task_argument)tty); if (sc != RTEMS_SUCCESSFUL)
48f0: e3500000 cmp r0, #0 <== NOT EXECUTED
48f4: 0affffee beq 48b4 <rtems_termios_open+0xb0> <== NOT EXECUTED
48f8: ea0000cb b 4c2c <rtems_termios_open+0x428> <== NOT EXECUTED
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
48fc: e3a00001 mov r0, #1
4900: e3a010e8 mov r1, #232 ; 0xe8
4904: ebfff551 bl 1e50 <calloc>
if (tty == NULL) {
4908: e3500000 cmp r0, #0
static char c = 'a';
/*
* Create a new device
*/
tty = calloc (1, sizeof (struct rtems_termios_tty));
490c: e58d0010 str r0, [sp, #16]
4910: e1a04000 mov r4, r0
if (tty == NULL) {
4914: 0a0000af beq 4bd8 <rtems_termios_open+0x3d4>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
4918: e59f0390 ldr r0, [pc, #912] ; 4cb0 <rtems_termios_open+0x4ac>
491c: e59d1010 ldr r1, [sp, #16]
4920: e5903004 ldr r3, [r0, #4]
4924: e5813064 str r3, [r1, #100] ; 0x64
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
4928: e5910064 ldr r0, [r1, #100] ; 0x64
492c: ebfff6b6 bl 240c <malloc>
4930: e59d2010 ldr r2, [sp, #16]
if (tty->rawInBuf.theBuf == NULL) {
4934: e3500000 cmp r0, #0
} /* * allocate raw input buffer */ tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE; tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
4938: e5820058 str r0, [r2, #88] ; 0x58
if (tty->rawInBuf.theBuf == NULL) {
493c: 0a0000a9 beq 4be8 <rtems_termios_open+0x3e4>
return RTEMS_NO_MEMORY;
}
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
4940: e59fc368 ldr ip, [pc, #872] ; 4cb0 <rtems_termios_open+0x4ac>
4944: e59de010 ldr lr, [sp, #16]
4948: e59c3008 ldr r3, [ip, #8]
494c: e58e3088 str r3, [lr, #136] ; 0x88
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
4950: e59e0088 ldr r0, [lr, #136] ; 0x88
4954: ebfff6ac bl 240c <malloc>
4958: e59d1010 ldr r1, [sp, #16]
if (tty->rawOutBuf.theBuf == NULL) {
495c: e3500000 cmp r0, #0
} /* * allocate raw output buffer */ tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE; tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
4960: e581007c str r0, [r1, #124] ; 0x7c
if (tty->rawOutBuf.theBuf == NULL) {
free((void *)(tty->rawInBuf.theBuf));
4964: 05910058 ldreq r0, [r1, #88] ; 0x58
/*
* allocate raw output buffer
*/
tty->rawOutBuf.Size = RAW_OUTPUT_BUFFER_SIZE;
tty->rawOutBuf.theBuf = malloc (tty->rawOutBuf.Size);
if (tty->rawOutBuf.theBuf == NULL) {
4968: 0a000097 beq 4bcc <rtems_termios_open+0x3c8>
return RTEMS_NO_MEMORY;
}
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
496c: e59f233c ldr r2, [pc, #828] ; 4cb0 <rtems_termios_open+0x4ac>
4970: e5920000 ldr r0, [r2]
4974: ebfff6a4 bl 240c <malloc>
4978: e59d3010 ldr r3, [sp, #16]
if (tty->cbuf == NULL) {
497c: e3500000 cmp r0, #0
return RTEMS_NO_MEMORY; } /* * allocate cooked buffer */ tty->cbuf = malloc (CBUFSIZE);
4980: e583001c str r0, [r3, #28]
if (tty->cbuf == NULL) {
4984: 0a00008c beq 4bbc <rtems_termios_open+0x3b8>
tty->tty_rcvwakeup = 0;
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
4988: e59b2000 ldr r2, [fp]
tty->back = NULL;
498c: e59dc010 ldr ip, [sp, #16]
return RTEMS_NO_MEMORY; } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL;
4990: e3a03000 mov r3, #0
/* * link tty */ tty->forw = rtems_termios_ttyHead; tty->back = NULL; if (rtems_termios_ttyHead != NULL)
4994: e3520000 cmp r2, #0
/*
* link tty
*/
tty->forw = rtems_termios_ttyHead;
tty->back = NULL;
4998: e88c000c stm ip, {r2, r3}
if (rtems_termios_ttyHead != NULL) rtems_termios_ttyHead->back = tty;
499c: 1582c004 strne ip, [r2, #4]
return RTEMS_NO_MEMORY; } /* * Initialize wakeup callbacks */ tty->tty_snd.sw_pfn = NULL;
49a0: e58c30d4 str r3, [ip, #212] ; 0xd4
tty->tty_snd.sw_arg = NULL;
49a4: e58c30d8 str r3, [ip, #216] ; 0xd8
tty->tty_rcv.sw_pfn = NULL;
49a8: e58c30dc str r3, [ip, #220] ; 0xdc
tty->tty_rcv.sw_arg = NULL;
49ac: e58c30e0 str r3, [ip, #224] ; 0xe0
tty->tty_rcvwakeup = 0;
49b0: e58c30e4 str r3, [ip, #228] ; 0xe4
tty->forw = rtems_termios_ttyHead; tty->back = NULL; if (rtems_termios_ttyHead != NULL) rtems_termios_ttyHead->back = tty; rtems_termios_ttyHead = tty; if (rtems_termios_ttyTail == NULL)
49b4: e59f32f8 ldr r3, [pc, #760] ; 4cb4 <rtems_termios_open+0x4b0>
49b8: e5932000 ldr r2, [r3]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
49bc: e59f12ec ldr r1, [pc, #748] ; 4cb0 <rtems_termios_open+0x4ac>
tty->forw = rtems_termios_ttyHead; tty->back = NULL; if (rtems_termios_ttyHead != NULL) rtems_termios_ttyHead->back = tty; rtems_termios_ttyHead = tty; if (rtems_termios_ttyTail == NULL)
49c0: e3520000 cmp r2, #0
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
49c4: e59d2010 ldr r2, [sp, #16]
49c8: e5d1000c ldrb r0, [r1, #12]
*/ tty->forw = rtems_termios_ttyHead; tty->back = NULL; if (rtems_termios_ttyHead != NULL) rtems_termios_ttyHead->back = tty; rtems_termios_ttyHead = tty;
49cc: e59de010 ldr lr, [sp, #16]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
49d0: e282c014 add ip, r2, #20
tty->back = NULL; if (rtems_termios_ttyHead != NULL) rtems_termios_ttyHead->back = tty; rtems_termios_ttyHead = tty; if (rtems_termios_ttyTail == NULL) rtems_termios_ttyTail = tty;
49d4: 0583e000 streq lr, [r3]
*/ tty->forw = rtems_termios_ttyHead; tty->back = NULL; if (rtems_termios_ttyHead != NULL) rtems_termios_ttyHead->back = tty; rtems_termios_ttyHead = tty;
49d8: e58be000 str lr, [fp]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
49dc: e3800315 orr r0, r0, #1409286144 ; 0x54000000
49e0: e58dc000 str ip, [sp]
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
49e4: e59dc010 ldr ip, [sp, #16]
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
49e8: e3800852 orr r0, r0, #5373952 ; 0x520000
49ec: e3a03000 mov r3, #0
49f0: e3800c69 orr r0, r0, #26880 ; 0x6900
49f4: e3a01001 mov r1, #1
49f8: e3a02054 mov r2, #84 ; 0x54
rtems_termios_ttyHead->back = tty;
rtems_termios_ttyHead = tty;
if (rtems_termios_ttyTail == NULL)
rtems_termios_ttyTail = tty;
tty->minor = minor;
49fc: e58c6010 str r6, [ip, #16]
tty->major = major;
4a00: e58c500c str r5, [ip, #12]
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
4a04: eb0002cd bl 5540 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'i', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
4a08: e2503000 subs r3, r0, #0
tty->major = major;
/*
* Set up mutex semaphores
*/
sc = rtems_semaphore_create (
4a0c: e59fb29c ldr fp, [pc, #668] ; 4cb0 <rtems_termios_open+0x4ac>
rtems_build_name ('T', 'R', 'i', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->isem);
if (sc != RTEMS_SUCCESSFUL)
4a10: 1a000085 bne 4c2c <rtems_termios_open+0x428>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
4a14: e5db000c ldrb r0, [fp, #12]
4a18: e59de010 ldr lr, [sp, #16]
4a1c: e3800315 orr r0, r0, #1409286144 ; 0x54000000
4a20: e3800852 orr r0, r0, #5373952 ; 0x520000
4a24: e28ec018 add ip, lr, #24
4a28: e3a01001 mov r1, #1
4a2c: e3800c6f orr r0, r0, #28416 ; 0x6f00
4a30: e3a02054 mov r2, #84 ; 0x54
4a34: e58dc000 str ip, [sp]
4a38: eb0002c0 bl 5540 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'o', c),
1,
RTEMS_BINARY_SEMAPHORE | RTEMS_INHERIT_PRIORITY | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->osem);
if (sc != RTEMS_SUCCESSFUL)
4a3c: e2501000 subs r1, r0, #0
4a40: 1a000079 bne 4c2c <rtems_termios_open+0x428>
rtems_fatal_error_occurred (sc);
sc = rtems_semaphore_create (
4a44: e5db000c ldrb r0, [fp, #12]
4a48: e59d2010 ldr r2, [sp, #16]
4a4c: e3800315 orr r0, r0, #1409286144 ; 0x54000000
4a50: e3800852 orr r0, r0, #5373952 ; 0x520000
4a54: e282c08c add ip, r2, #140 ; 0x8c
4a58: e3800b1e orr r0, r0, #30720 ; 0x7800
4a5c: e3a02020 mov r2, #32
4a60: e1a03001 mov r3, r1
4a64: e58dc000 str ip, [sp]
4a68: eb0002b4 bl 5540 <rtems_semaphore_create>
rtems_build_name ('T', 'R', 'x', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO,
RTEMS_NO_PRIORITY,
&tty->rawOutBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
4a6c: e250e000 subs lr, r0, #0
4a70: 1a00006d bne 4c2c <rtems_termios_open+0x428>
tty->rawOutBufState = rob_idle;
/*
* Set callbacks
*/
tty->device = *callbacks;
4a74: e8b9000f ldm r9!, {r0, r1, r2, r3}
4a78: e58d900c str r9, [sp, #12]
4a7c: e59d9010 ldr r9, [sp, #16]
4a80: e289c098 add ip, r9, #152 ; 0x98
4a84: e8ac000f stmia ip!, {r0, r1, r2, r3}
4a88: e59d900c ldr r9, [sp, #12]
4a8c: e899000f ldm r9, {r0, r1, r2, r3}
4a90: e88c000f stm ip, {r0, r1, r2, r3}
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
4a94: e59dc010 ldr ip, [sp, #16]
4a98: e59c30b4 ldr r3, [ip, #180] ; 0xb4
4a9c: e3530002 cmp r3, #2
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_FIFO, RTEMS_NO_PRIORITY, &tty->rawOutBuf.Semaphore); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); tty->rawOutBufState = rob_idle;
4aa0: e58ce094 str lr, [ip, #148] ; 0x94
tty->device = *callbacks;
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
4aa4: 0a000061 beq 4c30 <rtems_termios_open+0x42c>
&tty->rxTaskId);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
4aa8: e59d9010 ldr r9, [sp, #16]
4aac: e59930a0 ldr r3, [r9, #160] ; 0xa0
4ab0: e3530000 cmp r3, #0
4ab4: 0a00004e beq 4bf4 <rtems_termios_open+0x3f0>
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
4ab8: e59930b4 ldr r3, [r9, #180] ; 0xb4
4abc: e3530002 cmp r3, #2
4ac0: 0a00004b beq 4bf4 <rtems_termios_open+0x3f0>
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
4ac4: e59d0010 ldr r0, [sp, #16]
tty->termios.c_cc[VINTR] = '\003'; tty->termios.c_cc[VQUIT] = '\034'; tty->termios.c_cc[VERASE] = '\177'; tty->termios.c_cc[VKILL] = '\025'; tty->termios.c_cc[VEOF] = '\004'; tty->termios.c_cc[VEOL] = '\000';
4ac8: e3a03000 mov r3, #0
tty->termios.c_cc[VDISCARD] = '\017';
tty->termios.c_cc[VWERASE] = '\027';
tty->termios.c_cc[VLNEXT] = '\026';
/* start with no flow control, clear flow control flags */
tty->flow_ctrl = 0;
4acc: e58030b8 str r3, [r0, #184] ; 0xb8
/* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2;
4ad0: e5909064 ldr r9, [r0, #100] ; 0x64
tty->highwater = tty->rawInBuf.Size * 3/4;
4ad4: e590b064 ldr fp, [r0, #100] ; 0x64
/* * Bump name characer */ if (c++ == 'z')
4ad8: e59f11d0 ldr r1, [pc, #464] ; 4cb0 <rtems_termios_open+0x4ac>
/* start with no flow control, clear flow control flags */ tty->flow_ctrl = 0; /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2;
4adc: e1a090a9 lsr r9, r9, #1
4ae0: e58d9008 str r9, [sp, #8]
tty->highwater = tty->rawInBuf.Size * 3/4;
4ae4: e08bb08b add fp, fp, fp, lsl #1
4ae8: e59d9010 ldr r9, [sp, #16]
/* * Bump name characer */ if (c++ == 'z')
4aec: e5d1e00c ldrb lr, [r1, #12]
tty->flow_ctrl = 0; /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2; tty->highwater = tty->rawInBuf.Size * 3/4;
4af0: e1a0b12b lsr fp, fp, #2
4af4: e589b0c0 str fp, [r9, #192] ; 0xc0
/* * Bump name characer */ if (c++ == 'z')
4af8: e59f91b0 ldr r9, [pc, #432] ; 4cb0 <rtems_termios_open+0x4ac>
4afc: e35e007a cmp lr, #122 ; 0x7a
4b00: e28ee001 add lr, lr, #1
4b04: e5c9e00c strb lr, [r9, #12]
* Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; tty->termios.c_oflag = OPOST | ONLCR | XTABS; tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
4b08: e3a02c82 mov r2, #33280 ; 0x8200
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
4b0c: e59de010 ldr lr, [sp, #16]
tty->termios.c_oflag = OPOST | ONLCR | XTABS; tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL; tty->termios.c_lflag = ISIG | ICANON | IEXTEN | ECHO | ECHOK | ECHOE | ECHOCTL;
4b10: e282203b add r2, r2, #59 ; 0x3b
4b14: e58e203c str r2, [lr, #60] ; 0x3c
tty->termios.c_cc[VINTR] = '\003';
4b18: e3a02003 mov r2, #3
4b1c: e5ce2041 strb r2, [lr, #65] ; 0x41
tty->termios.c_cc[VQUIT] = '\034';
4b20: e3a0201c mov r2, #28
4b24: e5ce2042 strb r2, [lr, #66] ; 0x42
tty->termios.c_cc[VERASE] = '\177';
4b28: e3a0207f mov r2, #127 ; 0x7f
4b2c: e5ce2043 strb r2, [lr, #67] ; 0x43
tty->termios.c_cc[VKILL] = '\025';
4b30: e3a02015 mov r2, #21
4b34: e5ce2044 strb r2, [lr, #68] ; 0x44
tty->termios.c_cc[VEOF] = '\004';
4b38: e3a02004 mov r2, #4
4b3c: e5ce2045 strb r2, [lr, #69] ; 0x45
tty->termios.c_cc[VEOL] = '\000'; tty->termios.c_cc[VEOL2] = '\000'; tty->termios.c_cc[VSTART] = '\021';
4b40: e3a02011 mov r2, #17
4b44: e5ce2049 strb r2, [lr, #73] ; 0x49
tty->termios.c_cc[VSTOP] = '\023';
4b48: e3a02013 mov r2, #19
4b4c: e5ce204a strb r2, [lr, #74] ; 0x4a
tty->termios.c_cc[VSUSP] = '\032';
4b50: e3a0201a mov r2, #26
4b54: e5ce204b strb r2, [lr, #75] ; 0x4b
tty->termios.c_cc[VREPRINT] = '\022';
4b58: e3a02012 mov r2, #18
4b5c: e5ce204d strb r2, [lr, #77] ; 0x4d
tty->termios.c_cc[VDISCARD] = '\017';
4b60: e3a0200f mov r2, #15
4b64: e5ce204e strb r2, [lr, #78] ; 0x4e
tty->termios.c_cc[VWERASE] = '\027';
4b68: e3a02017 mov r2, #23
4b6c: e5ce204f strb r2, [lr, #79] ; 0x4f
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
4b70: e3a00b06 mov r0, #6144 ; 0x1800
tty->termios.c_cc[VSTOP] = '\023'; tty->termios.c_cc[VSUSP] = '\032'; tty->termios.c_cc[VREPRINT] = '\022'; tty->termios.c_cc[VDISCARD] = '\017'; tty->termios.c_cc[VWERASE] = '\027'; tty->termios.c_cc[VLNEXT] = '\026';
4b74: e3a02016 mov r2, #22
4b78: e5ce2050 strb r2, [lr, #80] ; 0x50
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
tty->termios.c_oflag = OPOST | ONLCR | XTABS;
4b7c: e2800005 add r0, r0, #5
4b80: e58e0034 str r0, [lr, #52] ; 0x34
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
4b84: e3a0cc25 mov ip, #9472 ; 0x2500
/* start with no flow control, clear flow control flags */ tty->flow_ctrl = 0; /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2;
4b88: e59d0008 ldr r0, [sp, #8]
/* * Set default parameters */ tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL; tty->termios.c_oflag = OPOST | ONLCR | XTABS; tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
4b8c: e3a01e8b mov r1, #2224 ; 0x8b0
tty->termios.c_cc[VINTR] = '\003'; tty->termios.c_cc[VQUIT] = '\034'; tty->termios.c_cc[VERASE] = '\177'; tty->termios.c_cc[VKILL] = '\025'; tty->termios.c_cc[VEOF] = '\004'; tty->termios.c_cc[VEOL] = '\000';
4b90: e5ce304c strb r3, [lr, #76] ; 0x4c
tty->termios.c_cc[VEOL2] = '\000';
4b94: e5ce3051 strb r3, [lr, #81] ; 0x51
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
4b98: e28cc002 add ip, ip, #2
tty->termios.c_oflag = OPOST | ONLCR | XTABS; tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
4b9c: e281100d add r1, r1, #13
tty->highwater = tty->rawInBuf.Size * 3/4; /* * Bump name characer */ if (c++ == 'z') c = 'a';
4ba0: 0282204b addeq r2, r2, #75 ; 0x4b
4ba4: 01a03009 moveq r3, r9
}
/*
* Set default parameters
*/
tty->termios.c_iflag = BRKINT | ICRNL | IXON | IMAXBEL;
4ba8: e58ec030 str ip, [lr, #48] ; 0x30
tty->termios.c_oflag = OPOST | ONLCR | XTABS; tty->termios.c_cflag = B9600 | CS8 | CREAD | CLOCAL;
4bac: e58e1038 str r1, [lr, #56] ; 0x38
/* start with no flow control, clear flow control flags */ tty->flow_ctrl = 0; /* * set low/highwater mark for XON/XOFF support */ tty->lowwater = tty->rawInBuf.Size * 1/2;
4bb0: e58e00bc str r0, [lr, #188] ; 0xbc
tty->highwater = tty->rawInBuf.Size * 3/4; /* * Bump name characer */ if (c++ == 'z') c = 'a';
4bb4: 05c3200c strbeq r2, [r3, #12]
4bb8: eaffff2c b 4870 <rtems_termios_open+0x6c>
/*
* allocate cooked buffer
*/
tty->cbuf = malloc (CBUFSIZE);
if (tty->cbuf == NULL) {
free((void *)(tty->rawOutBuf.theBuf));
4bbc: e593007c ldr r0, [r3, #124] ; 0x7c <== NOT EXECUTED
4bc0: ebfff538 bl 20a8 <free> <== NOT EXECUTED
free((void *)(tty->rawInBuf.theBuf));
4bc4: e59d9010 ldr r9, [sp, #16] <== NOT EXECUTED
4bc8: e5990058 ldr r0, [r9, #88] ; 0x58 <== NOT EXECUTED
4bcc: ebfff535 bl 20a8 <free> <== NOT EXECUTED
free(tty);
4bd0: e59d0010 ldr r0, [sp, #16] <== NOT EXECUTED
4bd4: ebfff533 bl 20a8 <free> <== NOT EXECUTED
rtems_semaphore_release (rtems_termios_ttyMutex);
4bd8: e5970000 ldr r0, [r7] <== NOT EXECUTED
4bdc: eb00033a bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
4be0: e3a0a01a mov sl, #26 <== NOT EXECUTED
return RTEMS_NO_MEMORY;
4be4: eaffff34 b 48bc <rtems_termios_open+0xb8> <== NOT EXECUTED
* allocate raw input buffer
*/
tty->rawInBuf.Size = RAW_INPUT_BUFFER_SIZE;
tty->rawInBuf.theBuf = malloc (tty->rawInBuf.Size);
if (tty->rawInBuf.theBuf == NULL) {
free(tty);
4be8: e1a00002 mov r0, r2 <== NOT EXECUTED
4bec: ebfff52d bl 20a8 <free> <== NOT EXECUTED
4bf0: eafffff8 b 4bd8 <rtems_termios_open+0x3d4> <== NOT EXECUTED
rtems_fatal_error_occurred (sc);
}
if ((tty->device.pollRead == NULL) ||
(tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN)){
sc = rtems_semaphore_create (
4bf4: e59fc0b4 ldr ip, [pc, #180] ; 4cb0 <rtems_termios_open+0x4ac><== NOT EXECUTED
4bf8: e5dc000c ldrb r0, [ip, #12] <== NOT EXECUTED
4bfc: e59de010 ldr lr, [sp, #16] <== NOT EXECUTED
4c00: e3800315 orr r0, r0, #1409286144 ; 0x54000000 <== NOT EXECUTED
4c04: e3a01000 mov r1, #0 <== NOT EXECUTED
4c08: e3800852 orr r0, r0, #5373952 ; 0x520000 <== NOT EXECUTED
4c0c: e28ec068 add ip, lr, #104 ; 0x68 <== NOT EXECUTED
4c10: e3800c72 orr r0, r0, #29184 ; 0x7200 <== NOT EXECUTED
4c14: e3a02024 mov r2, #36 ; 0x24 <== NOT EXECUTED
4c18: e1a03001 mov r3, r1 <== NOT EXECUTED
4c1c: e58dc000 str ip, [sp] <== NOT EXECUTED
4c20: eb000246 bl 5540 <rtems_semaphore_create> <== NOT EXECUTED
rtems_build_name ('T', 'R', 'r', c),
0,
RTEMS_SIMPLE_BINARY_SEMAPHORE | RTEMS_PRIORITY,
RTEMS_NO_PRIORITY,
&tty->rawInBuf.Semaphore);
if (sc != RTEMS_SUCCESSFUL)
4c24: e3500000 cmp r0, #0 <== NOT EXECUTED
4c28: 0affffa5 beq 4ac4 <rtems_termios_open+0x2c0> <== NOT EXECUTED
sc = rtems_task_start(tty->txTaskId,
rtems_termios_txdaemon,
(rtems_task_argument)tty);
if (sc != RTEMS_SUCCESSFUL)
rtems_fatal_error_occurred (sc);
4c2c: eb00046b bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
/*
* Create I/O tasks
*/
if (tty->device.outputUsesInterrupts == TERMIOS_TASK_DRIVEN) {
sc = rtems_task_create (
4c30: e5db000c ldrb r0, [fp, #12] <== NOT EXECUTED
4c34: e3800315 orr r0, r0, #1409286144 ; 0x54000000 <== NOT EXECUTED
4c38: e380071e orr r0, r0, #7864320 ; 0x780000 <== NOT EXECUTED
4c3c: e28cc0c8 add ip, ip, #200 ; 0xc8 <== NOT EXECUTED
4c40: e3800b15 orr r0, r0, #21504 ; 0x5400 <== NOT EXECUTED
4c44: e3a0100a mov r1, #10 <== NOT EXECUTED
4c48: e3a02b01 mov r2, #1024 ; 0x400 <== NOT EXECUTED
4c4c: e3a03c05 mov r3, #1280 ; 0x500 <== NOT EXECUTED
4c50: e58de000 str lr, [sp] <== NOT EXECUTED
4c54: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
4c58: eb000345 bl 5974 <rtems_task_create> <== NOT EXECUTED
TERMIOS_TXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->txTaskId); if (sc != RTEMS_SUCCESSFUL)
4c5c: e250e000 subs lr, r0, #0 <== NOT EXECUTED
4c60: 1afffff1 bne 4c2c <rtems_termios_open+0x428> <== NOT EXECUTED
rtems_fatal_error_occurred (sc); sc = rtems_task_create (
4c64: e5db000c ldrb r0, [fp, #12] <== NOT EXECUTED
4c68: e59d2010 ldr r2, [sp, #16] <== NOT EXECUTED
4c6c: e3800452 orr r0, r0, #1375731712 ; 0x52000000 <== NOT EXECUTED
4c70: e380071e orr r0, r0, #7864320 ; 0x780000 <== NOT EXECUTED
4c74: e282c0c4 add ip, r2, #196 ; 0xc4 <== NOT EXECUTED
4c78: e3800b15 orr r0, r0, #21504 ; 0x5400 <== NOT EXECUTED
4c7c: e3a01009 mov r1, #9 <== NOT EXECUTED
4c80: e3a02b01 mov r2, #1024 ; 0x400 <== NOT EXECUTED
4c84: e3a03c05 mov r3, #1280 ; 0x500 <== NOT EXECUTED
4c88: e58de000 str lr, [sp] <== NOT EXECUTED
4c8c: e58dc004 str ip, [sp, #4] <== NOT EXECUTED
4c90: eb000337 bl 5974 <rtems_task_create> <== NOT EXECUTED
TERMIOS_RXTASK_STACKSIZE, RTEMS_NO_PREEMPT | RTEMS_NO_TIMESLICE | RTEMS_NO_ASR, RTEMS_NO_FLOATING_POINT | RTEMS_LOCAL, &tty->rxTaskId); if (sc != RTEMS_SUCCESSFUL)
4c94: e3500000 cmp r0, #0 <== NOT EXECUTED
4c98: 0affff82 beq 4aa8 <rtems_termios_open+0x2a4> <== NOT EXECUTED
4c9c: eaffffe2 b 4c2c <rtems_termios_open+0x428> <== NOT EXECUTED
0000360c <rtems_termios_puts>:
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
360c: e59230b4 ldr r3, [r2, #180] ; 0xb4
3610: e3530000 cmp r3, #0
* Send characters to device-specific code
*/
void
rtems_termios_puts (
const void *_buf, int len, struct rtems_termios_tty *tty)
{
3614: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
3618: e1a04002 mov r4, r2
361c: e1a0b000 mov fp, r0
3620: e1a09001 mov r9, r1
const unsigned char *buf = _buf;
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
3624: 0a000039 beq 3710 <rtems_termios_puts+0x104>
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
3628: e3510000 cmp r1, #0 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
362c: e5928080 ldr r8, [r2, #128] ; 0x80 <== NOT EXECUTED
while (len) {
3630: 08bd8ff0 popeq {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
3634: e3a0a000 mov sl, #0 <== NOT EXECUTED
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
tty->rawOutBufState = rob_wait;
3638: e3a07002 mov r7, #2 <== NOT EXECUTED
* len -= ncopy * * To minimize latency, the memcpy should be done * with interrupts enabled. */ newHead = (newHead + 1) % tty->rawOutBuf.Size;
363c: e5941088 ldr r1, [r4, #136] ; 0x88 <== NOT EXECUTED
3640: e2880001 add r0, r8, #1 <== NOT EXECUTED
3644: eb0050eb bl 179f8 <__umodsi3> <== NOT EXECUTED
3648: e1a08000 mov r8, r0 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
364c: e10f5000 mrs r5, CPSR <== NOT EXECUTED
3650: e3853080 orr r3, r5, #128 ; 0x80 <== NOT EXECUTED
3654: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
3658: e5946084 ldr r6, [r4, #132] ; 0x84 <== NOT EXECUTED
365c: e1560000 cmp r6, r0 <== NOT EXECUTED
3660: 1a00000d bne 369c <rtems_termios_puts+0x90> <== NOT EXECUTED
tty->rawOutBufState = rob_wait;
3664: e5847094 str r7, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3668: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
rtems_interrupt_enable (level); sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore,
366c: e3a01000 mov r1, #0 <== NOT EXECUTED
3670: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED
3674: e1a02001 mov r2, r1 <== NOT EXECUTED
3678: eb00084b bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL)
367c: e3500000 cmp r0, #0 <== NOT EXECUTED
3680: 1a000028 bne 3728 <rtems_termios_puts+0x11c> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
3684: e10f5000 mrs r5, CPSR <== NOT EXECUTED
3688: e3853080 orr r3, r5, #128 ; 0x80 <== NOT EXECUTED
368c: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
* To minimize latency, the memcpy should be done
* with interrupts enabled.
*/
newHead = (newHead + 1) % tty->rawOutBuf.Size;
rtems_interrupt_disable (level);
while (newHead == tty->rawOutBuf.Tail) {
3690: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED
3694: e1530006 cmp r3, r6 <== NOT EXECUTED
3698: 0afffff1 beq 3664 <rtems_termios_puts+0x58> <== NOT EXECUTED
RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
369c: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED
36a0: e7db100a ldrb r1, [fp, sl] <== NOT EXECUTED
36a4: e594207c ldr r2, [r4, #124] ; 0x7c <== NOT EXECUTED
36a8: e7c21003 strb r1, [r2, r3] <== NOT EXECUTED
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
36ac: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
36b0: e3530000 cmp r3, #0 <== NOT EXECUTED
if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc); rtems_interrupt_disable (level); } tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++; tty->rawOutBuf.Head = newHead;
36b4: e5848080 str r8, [r4, #128] ; 0x80 <== NOT EXECUTED
if (tty->rawOutBufState == rob_idle) {
36b8: 1a000007 bne 36dc <rtems_termios_puts+0xd0> <== NOT EXECUTED
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
36bc: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
36c0: e3130010 tst r3, #16 <== NOT EXECUTED
36c4: 0a000009 beq 36f0 <rtems_termios_puts+0xe4> <== NOT EXECUTED
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
}
else {
/* remember that output has been stopped due to flow ctrl*/
tty->flow_ctrl |= FL_OSTOP;
36c8: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
36cc: e3833020 orr r3, r3, #32 <== NOT EXECUTED
36d0: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
} tty->rawOutBufState = rob_busy;
36d4: e3a03001 mov r3, #1 <== NOT EXECUTED
36d8: e5843094 str r3, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
36dc: e129f005 msr CPSR_fc, r5 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
36e0: e2599001 subs r9, r9, #1 <== NOT EXECUTED
tty->flow_ctrl |= FL_OSTOP; } tty->rawOutBufState = rob_busy; } rtems_interrupt_enable (level); len--;
36e4: e28aa001 add sl, sl, #1 <== NOT EXECUTED
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
return;
}
newHead = tty->rawOutBuf.Head;
while (len) {
36e8: 1affffd3 bne 363c <rtems_termios_puts+0x30> <== NOT EXECUTED
36ec: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(tty->minor,
(char *)&tty->rawOutBuf.theBuf[tty->rawOutBuf.Tail],1);
36f0: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED
tty->rawOutBuf.theBuf[tty->rawOutBuf.Head] = *buf++;
tty->rawOutBuf.Head = newHead;
if (tty->rawOutBufState == rob_idle) {
/* check, whether XOFF has been received */
if (!(tty->flow_ctrl & FL_ORCVXOF)) {
(*tty->device.write)(tty->minor,
36f4: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED
36f8: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
36fc: e0811003 add r1, r1, r3 <== NOT EXECUTED
3700: e3a02001 mov r2, #1 <== NOT EXECUTED
3704: e1a0e00f mov lr, pc <== NOT EXECUTED
3708: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
370c: eafffff0 b 36d4 <rtems_termios_puts+0xc8> <== NOT EXECUTED
unsigned int newHead;
rtems_interrupt_level level;
rtems_status_code sc;
if (tty->device.outputUsesInterrupts == TERMIOS_POLLED) {
(*tty->device.write)(tty->minor, (void *)buf, len);
3710: e1a01000 mov r1, r0
3714: e1a02009 mov r2, r9
3718: e5940010 ldr r0, [r4, #16]
371c: e1a0e00f mov lr, pc
3720: e594f0a4 ldr pc, [r4, #164] ; 0xa4
return;
3724: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
rtems_interrupt_enable (level); sc = rtems_semaphore_obtain (tty->rawOutBuf.Semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT); if (sc != RTEMS_SUCCESSFUL) rtems_fatal_error_occurred (sc);
3728: eb0009ac bl 5de0 <rtems_fatal_error_occurred> <== NOT EXECUTED
00003ea8 <rtems_termios_read>:
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
3ea8: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
3eac: e5903000 ldr r3, [r0]
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
3eb0: e1a0a000 mov sl, r0
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
3eb4: e5934034 ldr r4, [r3, #52] ; 0x34
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3eb8: e3a01000 mov r1, #0
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
char *buffer = args->buffer;
3ebc: e59a300c ldr r3, [sl, #12]
return RTEMS_SUCCESSFUL;
}
rtems_status_code
rtems_termios_read (void *arg)
{
3ec0: e24dd008 sub sp, sp, #8
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
char *buffer = args->buffer;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3ec4: e5940014 ldr r0, [r4, #20]
3ec8: e1a02001 mov r2, r1
rtems_status_code
rtems_termios_read (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
uint32_t count = args->count;
3ecc: e59a7010 ldr r7, [sl, #16]
char *buffer = args->buffer;
3ed0: e58d3000 str r3, [sp]
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3ed4: eb000634 bl 57ac <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
3ed8: e250b000 subs fp, r0, #0
3edc: 1a00000e bne 3f1c <rtems_termios_read+0x74>
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
3ee0: e59420cc ldr r2, [r4, #204] ; 0xcc
3ee4: e59f3364 ldr r3, [pc, #868] ; 4250 <rtems_termios_read+0x3a8>
3ee8: e0833282 add r3, r3, r2, lsl #5
3eec: e5933008 ldr r3, [r3, #8]
3ef0: e3530000 cmp r3, #0
3ef4: 0a00000b beq 3f28 <rtems_termios_read+0x80>
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
3ef8: e1a0100a mov r1, sl <== NOT EXECUTED
3efc: e1a00004 mov r0, r4 <== NOT EXECUTED
3f00: e1a0e00f mov lr, pc <== NOT EXECUTED
3f04: e12fff13 bx r3 <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
3f08: e3a03000 mov r3, #0 <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->isem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
if (sc != RTEMS_SUCCESSFUL)
return sc;
if (rtems_termios_linesw[tty->t_line].l_read != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
3f0c: e1a0b000 mov fp, r0 <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
3f10: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
rtems_semaphore_release (tty->isem);
3f14: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED
3f18: eb00066b bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
} args->bytes_moved = args->count - count; tty->tty_rcvwakeup = 0; rtems_semaphore_release (tty->isem); return sc; }
3f1c: e1a0000b mov r0, fp <== NOT EXECUTED
3f20: e28dd008 add sp, sp, #8 <== NOT EXECUTED
3f24: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
sc = rtems_termios_linesw[tty->t_line].l_read(tty,args);
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
3f28: e5942024 ldr r2, [r4, #36] ; 0x24
3f2c: e5943020 ldr r3, [r4, #32]
3f30: e1520003 cmp r2, r3
3f34: 0a00001a beq 3fa4 <rtems_termios_read+0xfc>
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
3f38: e3570000 cmp r7, #0 <== NOT EXECUTED
3f3c: 0a000010 beq 3f84 <rtems_termios_read+0xdc> <== NOT EXECUTED
3f40: e2842020 add r2, r4, #32 <== NOT EXECUTED
3f44: e892000c ldm r2, {r2, r3} <== NOT EXECUTED
3f48: e1530002 cmp r3, r2 <== NOT EXECUTED
3f4c: aa00000c bge 3f84 <rtems_termios_read+0xdc> <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
3f50: e59d2000 ldr r2, [sp] <== NOT EXECUTED
3f54: e0631002 rsb r1, r3, r2 <== NOT EXECUTED
3f58: ea000002 b 3f68 <rtems_termios_read+0xc0> <== NOT EXECUTED
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
3f5c: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
3f60: e1520003 cmp r2, r3 <== NOT EXECUTED
3f64: da000006 ble 3f84 <rtems_termios_read+0xdc> <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
3f68: e594201c ldr r2, [r4, #28] <== NOT EXECUTED
3f6c: e7d22003 ldrb r2, [r2, r3] <== NOT EXECUTED
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
3f70: e2577001 subs r7, r7, #1 <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++];
3f74: e7c12003 strb r2, [r1, r3] <== NOT EXECUTED
3f78: e2833001 add r3, r3, #1 <== NOT EXECUTED
3f7c: e5843024 str r3, [r4, #36] ; 0x24 <== NOT EXECUTED
else
sc = fillBufferQueue (tty);
if (sc != RTEMS_SUCCESSFUL)
tty->cindex = tty->ccount = 0;
}
while (count && (tty->cindex < tty->ccount)) {
3f80: 1afffff5 bne 3f5c <rtems_termios_read+0xb4> <== NOT EXECUTED
*buffer++ = tty->cbuf[tty->cindex++]; count--; } args->bytes_moved = args->count - count;
3f84: e59a3010 ldr r3, [sl, #16] <== NOT EXECUTED
3f88: e0677003 rsb r7, r7, r3 <== NOT EXECUTED
3f8c: e58a7018 str r7, [sl, #24] <== NOT EXECUTED
tty->tty_rcvwakeup = 0;
3f90: e3a03000 mov r3, #0 <== NOT EXECUTED
3f94: e58430e4 str r3, [r4, #228] ; 0xe4 <== NOT EXECUTED
rtems_semaphore_release (tty->isem);
3f98: e5940014 ldr r0, [r4, #20] <== NOT EXECUTED
3f9c: eb00064a bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
return sc;
3fa0: eaffffdd b 3f1c <rtems_termios_read+0x74> <== NOT EXECUTED
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL
&& tty->device.outputUsesInterrupts == TERMIOS_POLLED)
3fa4: e59430a0 ldr r3, [r4, #160] ; 0xa0
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
3fa8: e5942028 ldr r2, [r4, #40] ; 0x28
if (tty->device.pollRead != NULL
3fac: e3530000 cmp r3, #0
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
tty->read_start_column = tty->column;
3fb0: e584202c str r2, [r4, #44] ; 0x2c
tty->tty_rcvwakeup = 0;
rtems_semaphore_release (tty->isem);
return sc;
}
if (tty->cindex == tty->ccount) {
tty->cindex = tty->ccount = 0;
3fb4: e584b020 str fp, [r4, #32]
3fb8: e584b024 str fp, [r4, #36] ; 0x24
tty->read_start_column = tty->column;
if (tty->device.pollRead != NULL
3fbc: 0a000002 beq 3fcc <rtems_termios_read+0x124>
&& tty->device.outputUsesInterrupts == TERMIOS_POLLED)
3fc0: e59420b4 ldr r2, [r4, #180] ; 0xb4
3fc4: e3520000 cmp r2, #0
3fc8: 0a000064 beq 4160 <rtems_termios_read+0x2b8>
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(tty->minor,
3fcc: e2842049 add r2, r4, #73 ; 0x49 <== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
3fd0: e3a09c02 mov r9, #512 ; 0x200 <== NOT EXECUTED
* Fill the input buffer from the raw input queue
*/
static rtems_status_code
fillBufferQueue (struct rtems_termios_tty *tty)
{
rtems_interval timeout = tty->rawInBufSemaphoreFirstTimeout;
3fd4: e5945074 ldr r5, [r4, #116] ; 0x74 <== NOT EXECUTED
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(tty->minor,
3fd8: e58d2004 str r2, [sp, #4] <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
3fdc: e59f6270 ldr r6, [pc, #624] ; 4254 <rtems_termios_read+0x3ac><== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
3fe0: e2899002 add r9, r9, #2 <== NOT EXECUTED
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(tty->minor,
3fe4: e3a08001 mov r8, #1 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
3fe8: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED
3fec: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
3ff0: e1520003 cmp r2, r3 <== NOT EXECUTED
3ff4: 0a00003b beq 40e8 <rtems_termios_read+0x240> <== NOT EXECUTED
3ff8: e5962000 ldr r2, [r6] <== NOT EXECUTED
3ffc: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED
4000: e2422001 sub r2, r2, #1 <== NOT EXECUTED
4004: e1520003 cmp r2, r3 <== NOT EXECUTED
4008: da000036 ble 40e8 <rtems_termios_read+0x240> <== NOT EXECUTED
(tty->ccount < (CBUFSIZE-1))) {
unsigned char c;
unsigned int newHead;
newHead = (tty->rawInBuf.Head + 1) % tty->rawInBuf.Size;
400c: e594005c ldr r0, [r4, #92] ; 0x5c <== NOT EXECUTED
4010: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED
4014: e2800001 add r0, r0, #1 <== NOT EXECUTED
4018: eb004e76 bl 179f8 <__umodsi3> <== NOT EXECUTED
c = tty->rawInBuf.theBuf[newHead];
401c: e5943058 ldr r3, [r4, #88] ; 0x58 <== NOT EXECUTED
4020: e7d35000 ldrb r5, [r3, r0] <== NOT EXECUTED
tty->rawInBuf.Head = newHead;
4024: e584005c str r0, [r4, #92] ; 0x5c <== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
4028: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
402c: e5942064 ldr r2, [r4, #100] ; 0x64 <== NOT EXECUTED
4030: e0823003 add r3, r2, r3 <== NOT EXECUTED
4034: e0600003 rsb r0, r0, r3 <== NOT EXECUTED
4038: e5941064 ldr r1, [r4, #100] ; 0x64 <== NOT EXECUTED
403c: eb004e6d bl 179f8 <__umodsi3> <== NOT EXECUTED
4040: e59430bc ldr r3, [r4, #188] ; 0xbc <== NOT EXECUTED
4044: e1500003 cmp r0, r3 <== NOT EXECUTED
4048: 2a000014 bcs 40a0 <rtems_termios_read+0x1f8> <== NOT EXECUTED
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
404c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4050: e3c33001 bic r3, r3, #1 <== NOT EXECUTED
4054: e58430b8 str r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* if tx stopped and XON should be sent... */ if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
4058: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
405c: e3c33f7f bic r3, r3, #508 ; 0x1fc <== NOT EXECUTED
4060: e3c33001 bic r3, r3, #1 <== NOT EXECUTED
4064: e1a03b03 lsl r3, r3, #22 <== NOT EXECUTED
4068: e1a03b23 lsr r3, r3, #22 <== NOT EXECUTED
406c: e1530009 cmp r3, r9 <== NOT EXECUTED
4070: 0a00002e beq 4130 <rtems_termios_read+0x288> <== NOT EXECUTED
/* XON should be sent now... */
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTART]),
1);
}
else if (tty->flow_ctrl & FL_MDRTS) {
4074: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
4078: e3130c01 tst r3, #256 ; 0x100 <== NOT EXECUTED
407c: 0a000007 beq 40a0 <rtems_termios_read+0x1f8> <== NOT EXECUTED
tty->flow_ctrl &= ~FL_IRTSOFF;
4080: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
4084: e59430b0 ldr r3, [r4, #176] ; 0xb0 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTART]),
1);
}
else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
4088: e3c22004 bic r2, r2, #4 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
408c: e3530000 cmp r3, #0 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTART]),
1);
}
else if (tty->flow_ctrl & FL_MDRTS) {
tty->flow_ctrl &= ~FL_IRTSOFF;
4090: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* activate RTS line */
if (tty->device.startRemoteTx != NULL) {
tty->device.startRemoteTx(tty->minor);
4094: 15940010 ldrne r0, [r4, #16] <== NOT EXECUTED
4098: 11a0e00f movne lr, pc <== NOT EXECUTED
409c: 112fff13 bxne r3 <== NOT EXECUTED
}
}
}
/* continue processing new character */
if (tty->termios.c_lflag & ICANON) {
40a0: e594303c ldr r3, [r4, #60] ; 0x3c <== NOT EXECUTED
40a4: e3130002 tst r3, #2 <== NOT EXECUTED
40a8: 0a000017 beq 410c <rtems_termios_read+0x264> <== NOT EXECUTED
if (siproc (c, tty))
40ac: e1a00005 mov r0, r5 <== NOT EXECUTED
40b0: e1a01004 mov r1, r4 <== NOT EXECUTED
40b4: ebffff0f bl 3cf8 <siproc> <== NOT EXECUTED
40b8: e3500000 cmp r0, #0 <== NOT EXECUTED
40bc: 1a000019 bne 4128 <rtems_termios_read+0x280> <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
40c0: e594205c ldr r2, [r4, #92] ; 0x5c <== NOT EXECUTED
40c4: e5943060 ldr r3, [r4, #96] ; 0x60 <== NOT EXECUTED
40c8: e1520003 cmp r2, r3 <== NOT EXECUTED
else {
siproc (c, tty);
if (tty->ccount >= tty->termios.c_cc[VMIN])
wait = 0;
}
timeout = tty->rawInBufSemaphoreTimeout;
40cc: e5945070 ldr r5, [r4, #112] ; 0x70 <== NOT EXECUTED
while ( wait ) {
/*
* Process characters read from raw queue
*/
while ((tty->rawInBuf.Head != tty->rawInBuf.Tail) &&
40d0: 0a000004 beq 40e8 <rtems_termios_read+0x240> <== NOT EXECUTED
40d4: e5963000 ldr r3, [r6] <== NOT EXECUTED
40d8: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
40dc: e2433001 sub r3, r3, #1 <== NOT EXECUTED
40e0: e1520003 cmp r2, r3 <== NOT EXECUTED
40e4: baffffc8 blt 400c <rtems_termios_read+0x164> <== NOT EXECUTED
}
/*
* Wait for characters
*/
if ( wait ) {
40e8: e3580000 cmp r8, #0 <== NOT EXECUTED
40ec: 0affff91 beq 3f38 <rtems_termios_read+0x90> <== NOT EXECUTED
sc = rtems_semaphore_obtain (tty->rawInBuf.Semaphore,
40f0: e2840068 add r0, r4, #104 ; 0x68 <== NOT EXECUTED
40f4: e8900003 ldm r0, {r0, r1} <== NOT EXECUTED
40f8: e1a02005 mov r2, r5 <== NOT EXECUTED
40fc: eb0005aa bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
tty->rawInBufSemaphoreOptions, timeout); if (sc != RTEMS_SUCCESSFUL)
4100: e3500000 cmp r0, #0 <== NOT EXECUTED
4104: 0affffb7 beq 3fe8 <rtems_termios_read+0x140> <== NOT EXECUTED
4108: eaffff8a b 3f38 <rtems_termios_read+0x90> <== NOT EXECUTED
if (tty->termios.c_lflag & ICANON) {
if (siproc (c, tty))
wait = 0;
}
else {
siproc (c, tty);
410c: e1a00005 mov r0, r5 <== NOT EXECUTED
4110: e1a01004 mov r1, r4 <== NOT EXECUTED
4114: ebfffef7 bl 3cf8 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
4118: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED
411c: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
4120: e1520003 cmp r2, r3 <== NOT EXECUTED
4124: baffffe5 blt 40c0 <rtems_termios_read+0x218> <== NOT EXECUTED
4128: e3a08000 mov r8, #0 <== NOT EXECUTED
412c: eaffffe3 b 40c0 <rtems_termios_read+0x218> <== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
4130: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
4134: e3530000 cmp r3, #0 <== NOT EXECUTED
4138: 0a000002 beq 4148 <rtems_termios_read+0x2a0> <== NOT EXECUTED
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
413c: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
if(((tty->rawInBuf.Tail-newHead+tty->rawInBuf.Size)
% tty->rawInBuf.Size)
< tty->lowwater) {
tty->flow_ctrl &= ~FL_IREQXOF;
/* if tx stopped and XON should be sent... */
if (((tty->flow_ctrl & (FL_MDXON | FL_ISNTXOF))
4140: e3130020 tst r3, #32 <== NOT EXECUTED
4144: 0affffca beq 4074 <rtems_termios_read+0x1cc> <== NOT EXECUTED
== (FL_MDXON | FL_ISNTXOF))
&& ((tty->rawOutBufState == rob_idle)
|| (tty->flow_ctrl & FL_OSTOP))) {
/* XON should be sent now... */
(*tty->device.write)(tty->minor,
4148: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
414c: e59d1004 ldr r1, [sp, #4] <== NOT EXECUTED
4150: e3a02001 mov r2, #1 <== NOT EXECUTED
4154: e1a0e00f mov lr, pc <== NOT EXECUTED
4158: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
415c: eaffffcf b 40a0 <rtems_termios_read+0x1f8> <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
4160: e594203c ldr r2, [r4, #60] ; 0x3c
4164: e3120002 tst r2, #2
4168: 0a00000b beq 419c <rtems_termios_read+0x2f4>
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
416c: e5940010 ldr r0, [r4, #16]
4170: e1a0e00f mov lr, pc
4174: e12fff13 bx r3
if (n < 0) {
4178: e3500000 cmp r0, #0
rtems_task_wake_after (1);
}
else {
if (siproc (n, tty))
417c: e1a01004 mov r1, r4
4180: e20000ff and r0, r0, #255 ; 0xff
int n;
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
4184: ba00002d blt 4240 <rtems_termios_read+0x398>
rtems_task_wake_after (1);
}
else {
if (siproc (n, tty))
4188: ebfffeda bl 3cf8 <siproc> <== NOT EXECUTED
418c: e3500000 cmp r0, #0 <== NOT EXECUTED
4190: 1affff68 bne 3f38 <rtems_termios_read+0x90> <== NOT EXECUTED
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
4194: e59430a0 ldr r3, [r4, #160] ; 0xa0 <== NOT EXECUTED
4198: eafffff3 b 416c <rtems_termios_read+0x2c4> <== NOT EXECUTED
}
}
}
else {
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
419c: eb0003de bl 511c <rtems_clock_get_ticks_since_boot>
41a0: e1a05000 mov r5, r0
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
41a4: e5940010 ldr r0, [r4, #16]
41a8: e1a0e00f mov lr, pc
41ac: e594f0a0 ldr pc, [r4, #160] ; 0xa0
if (n < 0) {
41b0: e3500000 cmp r0, #0
41b4: ba00000c blt 41ec <rtems_termios_read+0x344>
}
}
rtems_task_wake_after (1);
}
else {
siproc (n, tty);
41b8: e20000ff and r0, r0, #255 ; 0xff <== NOT EXECUTED
41bc: e1a01004 mov r1, r4 <== NOT EXECUTED
41c0: ebfffecc bl 3cf8 <siproc> <== NOT EXECUTED
if (tty->ccount >= tty->termios.c_cc[VMIN])
41c4: e5d43047 ldrb r3, [r4, #71] ; 0x47 <== NOT EXECUTED
41c8: e5942020 ldr r2, [r4, #32] <== NOT EXECUTED
41cc: e1520003 cmp r2, r3 <== NOT EXECUTED
41d0: aaffff58 bge 3f38 <rtems_termios_read+0x90> <== NOT EXECUTED
break; if (tty->termios.c_cc[VMIN] && tty->termios.c_cc[VTIME])
41d4: e3530000 cmp r3, #0 <== NOT EXECUTED
41d8: 0afffff1 beq 41a4 <rtems_termios_read+0x2fc> <== NOT EXECUTED
41dc: e5d43046 ldrb r3, [r4, #70] ; 0x46 <== NOT EXECUTED
41e0: e3530000 cmp r3, #0 <== NOT EXECUTED
41e4: 0affffee beq 41a4 <rtems_termios_read+0x2fc> <== NOT EXECUTED
41e8: eaffffeb b 419c <rtems_termios_read+0x2f4> <== NOT EXECUTED
rtems_interval then, now;
then = rtems_clock_get_ticks_since_boot();
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
if (tty->termios.c_cc[VMIN]) {
41ec: e5d43047 ldrb r3, [r4, #71] ; 0x47
41f0: e3530000 cmp r3, #0
41f4: 0a000008 beq 421c <rtems_termios_read+0x374>
if (tty->termios.c_cc[VTIME] && tty->ccount) {
41f8: e5d43046 ldrb r3, [r4, #70] ; 0x46
41fc: e3530000 cmp r3, #0
4200: 0a000002 beq 4210 <rtems_termios_read+0x368>
4204: e5943020 ldr r3, [r4, #32] <== NOT EXECUTED
4208: e3530000 cmp r3, #0 <== NOT EXECUTED
420c: 1a000005 bne 4228 <rtems_termios_read+0x380> <== NOT EXECUTED
now = rtems_clock_get_ticks_since_boot();
if ((now - then) > tty->vtimeTicks) {
break;
}
}
rtems_task_wake_after (1);
4210: e3a00001 mov r0, #1
4214: eb000697 bl 5c78 <rtems_task_wake_after>
4218: eaffffe1 b 41a4 <rtems_termios_read+0x2fc>
break;
}
}
}
else {
if (!tty->termios.c_cc[VTIME])
421c: e5d43046 ldrb r3, [r4, #70] ; 0x46 <== NOT EXECUTED
4220: e3530000 cmp r3, #0 <== NOT EXECUTED
4224: 0affff43 beq 3f38 <rtems_termios_read+0x90> <== NOT EXECUTED
break; now = rtems_clock_get_ticks_since_boot();
4228: eb0003bb bl 511c <rtems_clock_get_ticks_since_boot> <== NOT EXECUTED
if ((now - then) > tty->vtimeTicks) {
422c: e5943054 ldr r3, [r4, #84] ; 0x54 <== NOT EXECUTED
4230: e0650000 rsb r0, r5, r0 <== NOT EXECUTED
4234: e1500003 cmp r0, r3 <== NOT EXECUTED
4238: 9afffff4 bls 4210 <rtems_termios_read+0x368> <== NOT EXECUTED
423c: eaffff3d b 3f38 <rtems_termios_read+0x90> <== NOT EXECUTED
if (tty->termios.c_lflag & ICANON) {
for (;;) {
n = (*tty->device.pollRead)(tty->minor);
if (n < 0) {
rtems_task_wake_after (1);
4240: e3a00001 mov r0, #1
4244: eb00068b bl 5c78 <rtems_task_wake_after>
static rtems_status_code
fillBufferPoll (struct rtems_termios_tty *tty)
{
int n;
if (tty->termios.c_lflag & ICANON) {
4248: e59430a0 ldr r3, [r4, #160] ; 0xa0
424c: eaffffc6 b 416c <rtems_termios_read+0x2c4>
000030a4 <rtems_termios_refill_transmitter>:
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
30a4: e59030b8 ldr r3, [r0, #184] ; 0xb8 <== NOT EXECUTED
30a8: e3c33fff bic r3, r3, #1020 ; 0x3fc <== NOT EXECUTED
30ac: e1a03a83 lsl r3, r3, #21 <== NOT EXECUTED
30b0: e3a02b01 mov r2, #1024 ; 0x400 <== NOT EXECUTED
30b4: e1a03aa3 lsr r3, r3, #21 <== NOT EXECUTED
30b8: e2822001 add r2, r2, #1 <== NOT EXECUTED
30bc: e1530002 cmp r3, r2 <== NOT EXECUTED
* in task-driven mode, this function is called in Tx task context
* in interrupt-driven mode, this function is called in TxIRQ context
*/
int
rtems_termios_refill_transmitter (struct rtems_termios_tty *tty)
{
30c0: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
30c4: e1a04000 mov r4, r0 <== NOT EXECUTED
int nToSend;
rtems_interrupt_level level;
int len;
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
30c8: 0a000046 beq 31e8 <rtems_termios_refill_transmitter+0x144> <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
rtems_interrupt_enable(level);
nToSend = 1;
}
else if ((tty->flow_ctrl & (FL_IREQXOF | FL_ISNTXOF))
30cc: e59030b8 ldr r3, [r0, #184] ; 0xb8 <== NOT EXECUTED
30d0: e2033003 and r3, r3, #3 <== NOT EXECUTED
30d4: e3530002 cmp r3, #2 <== NOT EXECUTED
30d8: 0a000054 beq 3230 <rtems_termios_refill_transmitter+0x18c> <== NOT EXECUTED
rtems_interrupt_enable(level);
nToSend = 1;
}
else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
30dc: e5902080 ldr r2, [r0, #128] ; 0x80 <== NOT EXECUTED
30e0: e5903084 ldr r3, [r0, #132] ; 0x84 <== NOT EXECUTED
30e4: e1520003 cmp r2, r3 <== NOT EXECUTED
30e8: 0a00002a beq 3198 <rtems_termios_refill_transmitter+0xf4> <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
30ec: e10f3000 mrs r3, CPSR <== NOT EXECUTED
30f0: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
30f4: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
30f8: e3a02000 mov r2, #0 <== NOT EXECUTED
}
return 0;
}
rtems_interrupt_disable(level);
len = tty->t_dqlen;
30fc: e5900090 ldr r0, [r0, #144] ; 0x90 <== NOT EXECUTED
tty->t_dqlen = 0;
3100: e5842090 str r2, [r4, #144] ; 0x90 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3104: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
3108: e5943084 ldr r3, [r4, #132] ; 0x84 <== NOT EXECUTED
310c: e5941088 ldr r1, [r4, #136] ; 0x88 <== NOT EXECUTED
3110: e0800003 add r0, r0, r3 <== NOT EXECUTED
3114: eb005237 bl 179f8 <__umodsi3> <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
3118: e5943094 ldr r3, [r4, #148] ; 0x94 <== NOT EXECUTED
311c: e3530002 cmp r3, #2 <== NOT EXECUTED
rtems_interrupt_disable(level);
len = tty->t_dqlen;
tty->t_dqlen = 0;
rtems_interrupt_enable(level);
newTail = (tty->rawOutBuf.Tail + len) % tty->rawOutBuf.Size;
3120: e1a05000 mov r5, r0 <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
3124: e5840084 str r0, [r4, #132] ; 0x84 <== NOT EXECUTED
if (tty->rawOutBufState == rob_wait) {
3128: 0a00002b beq 31dc <rtems_termios_refill_transmitter+0x138> <== NOT EXECUTED
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
}
if (newTail == tty->rawOutBuf.Head) {
312c: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED
3130: e1530005 cmp r3, r5 <== NOT EXECUTED
3134: 0a00001d beq 31b0 <rtems_termios_refill_transmitter+0x10c> <== NOT EXECUTED
if ( tty->tty_snd.sw_pfn != NULL) {
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
}
}
/* check, whether output should stop due to received XOFF */
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
3138: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
313c: e2033e21 and r3, r3, #528 ; 0x210 <== NOT EXECUTED
3140: e3530e21 cmp r3, #528 ; 0x210 <== NOT EXECUTED
3144: 0a000046 beq 3264 <rtems_termios_refill_transmitter+0x1c0> <== NOT EXECUTED
}
else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
3148: e5943080 ldr r3, [r4, #128] ; 0x80 <== NOT EXECUTED
314c: e1550003 cmp r5, r3 <== NOT EXECUTED
nToSend = tty->rawOutBuf.Size - newTail;
3150: 85946088 ldrhi r6, [r4, #136] ; 0x88 <== NOT EXECUTED
else nToSend = tty->rawOutBuf.Head - newTail;
3154: 95946080 ldrls r6, [r4, #128] ; 0x80 <== NOT EXECUTED
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
3158: e59430b8 ldr r3, [r4, #184] ; 0xb8 <== NOT EXECUTED
else {
/*
* Buffer not empty, start tranmitter
*/
if (newTail > tty->rawOutBuf.Head)
nToSend = tty->rawOutBuf.Size - newTail;
315c: 80656006 rsbhi r6, r5, r6 <== NOT EXECUTED
else nToSend = tty->rawOutBuf.Head - newTail;
3160: 90656006 rsbls r6, r5, r6 <== NOT EXECUTED
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
nToSend = 1;
}
tty->rawOutBufState = rob_busy; /*apm*/
(*tty->device.write)(tty->minor,
3164: e594107c ldr r1, [r4, #124] ; 0x7c <== NOT EXECUTED
else
nToSend = tty->rawOutBuf.Head - newTail;
/* when flow control XON or XOF, don't send blocks of data */
/* to allow fast reaction on incoming flow ctrl and low latency*/
/* for outgoing flow control */
if (tty->flow_ctrl & (FL_MDXON | FL_MDXOF)) {
3168: e3130c06 tst r3, #1536 ; 0x600 <== NOT EXECUTED
316c: 13a06001 movne r6, #1 <== NOT EXECUTED
nToSend = 1; } tty->rawOutBufState = rob_busy; /*apm*/
3170: e3a03001 mov r3, #1 <== NOT EXECUTED
3174: e5843094 str r3, [r4, #148] ; 0x94 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
3178: e0811005 add r1, r1, r5 <== NOT EXECUTED
317c: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
3180: e1a02006 mov r2, r6 <== NOT EXECUTED
3184: e1a0e00f mov lr, pc <== NOT EXECUTED
3188: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
&tty->rawOutBuf.theBuf[newTail], nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/
318c: e5845084 str r5, [r4, #132] ; 0x84 <== NOT EXECUTED
} return nToSend; }
3190: e1a00006 mov r0, r6 <== NOT EXECUTED
3194: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
else {
if ( tty->rawOutBuf.Head == tty->rawOutBuf.Tail ) {
/*
* buffer was empty
*/
if (tty->rawOutBufState == rob_wait) {
3198: e5903094 ldr r3, [r0, #148] ; 0x94 <== NOT EXECUTED
319c: e3530002 cmp r3, #2 <== NOT EXECUTED
31a0: 0a00003a beq 3290 <rtems_termios_refill_transmitter+0x1ec> <== NOT EXECUTED
/* * this should never happen... */ rtems_semaphore_release (tty->rawOutBuf.Semaphore);
31a4: e3a06000 mov r6, #0 <== NOT EXECUTED
nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; }
31a8: e1a00006 mov r0, r6 <== NOT EXECUTED
31ac: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
31b0: e59430d4 ldr r3, [r4, #212] ; 0xd4 <== NOT EXECUTED
}
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
31b4: e3a06000 mov r6, #0 <== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
31b8: e3530000 cmp r3, #0 <== NOT EXECUTED
}
if (newTail == tty->rawOutBuf.Head) {
/*
* Buffer has become empty
*/
tty->rawOutBufState = rob_idle;
31bc: e5846094 str r6, [r4, #148] ; 0x94 <== NOT EXECUTED
nToSend = 0;
/*
* check to see if snd wakeup callback was set
*/
if ( tty->tty_snd.sw_pfn != NULL) {
31c0: 01a06003 moveq r6, r3 <== NOT EXECUTED
31c4: 0afffff0 beq 318c <rtems_termios_refill_transmitter+0xe8> <== NOT EXECUTED
(*tty->tty_snd.sw_pfn)(&tty->termios, tty->tty_snd.sw_arg);
31c8: e2840030 add r0, r4, #48 ; 0x30 <== NOT EXECUTED
31cc: e59410d8 ldr r1, [r4, #216] ; 0xd8 <== NOT EXECUTED
31d0: e1a0e00f mov lr, pc <== NOT EXECUTED
31d4: e12fff13 bx r3 <== NOT EXECUTED
31d8: eaffffeb b 318c <rtems_termios_refill_transmitter+0xe8> <== NOT EXECUTED
tty->rawOutBuf.Tail = newTail;
if (tty->rawOutBufState == rob_wait) {
/*
* wake up any pending writer task
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
31dc: e594008c ldr r0, [r4, #140] ; 0x8c <== NOT EXECUTED
31e0: eb0009b9 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
31e4: eaffffd0 b 312c <rtems_termios_refill_transmitter+0x88> <== NOT EXECUTED
/* check for XOF/XON to send */
if ((tty->flow_ctrl & (FL_MDXOF | FL_IREQXOF | FL_ISNTXOF))
== (FL_MDXOF | FL_IREQXOF)) {
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor,
31e8: e284104a add r1, r4, #74 ; 0x4a <== NOT EXECUTED
31ec: e3a02001 mov r2, #1 <== NOT EXECUTED
31f0: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
31f4: e1a0e00f mov lr, pc <== NOT EXECUTED
31f8: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
31fc: e10f3000 mrs r3, CPSR <== NOT EXECUTED
3200: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
3204: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
3208: e5942090 ldr r2, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
320c: e59410b8 ldr r1, [r4, #184] ; 0xb8 <== NOT EXECUTED
/* XOFF should be sent now... */
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTOP]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
3210: e2422001 sub r2, r2, #1 <== NOT EXECUTED
tty->flow_ctrl |= FL_ISNTXOF;
3214: e3811002 orr r1, r1, #2 <== NOT EXECUTED
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
tty->flow_ctrl &= ~FL_ISNTXOF;
3218: e58410b8 str r1, [r4, #184] ; 0xb8 <== NOT EXECUTED
*/
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
321c: e5842090 str r2, [r4, #144] ; 0x90 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3220: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
3224: e3a06001 mov r6, #1 <== NOT EXECUTED
nToSend); } tty->rawOutBuf.Tail = newTail; /*apm*/ } return nToSend; }
3228: e1a00006 mov r0, r6 <== NOT EXECUTED
322c: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
* FIXME: this .write call will generate another * dequeue callback. This will advance the "Tail" in the data * buffer, although the corresponding data is not yet out! * Therefore the dequeue "length" should be reduced by 1 */ (*tty->device.write)(tty->minor,
3230: e2841049 add r1, r4, #73 ; 0x49 <== NOT EXECUTED
3234: e3a02001 mov r2, #1 <== NOT EXECUTED
3238: e5900010 ldr r0, [r0, #16] <== NOT EXECUTED
323c: e1a0e00f mov lr, pc <== NOT EXECUTED
3240: e594f0a4 ldr pc, [r4, #164] ; 0xa4 <== NOT EXECUTED
static inline uint32_t arm_interrupt_disable( void )
{
uint32_t arm_switch_reg;
uint32_t level;
asm volatile (
3244: e10f3000 mrs r3, CPSR <== NOT EXECUTED
3248: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
324c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
(void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
3250: e5942090 ldr r2, [r4, #144] ; 0x90 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
3254: e59410b8 ldr r1, [r4, #184] ; 0xb8 <== NOT EXECUTED
*/
(*tty->device.write)(tty->minor,
(void *)&(tty->termios.c_cc[VSTART]), 1);
rtems_interrupt_disable(level);
tty->t_dqlen--;
3258: e2422001 sub r2, r2, #1 <== NOT EXECUTED
tty->flow_ctrl &= ~FL_ISNTXOF;
325c: e3c11002 bic r1, r1, #2 <== NOT EXECUTED
3260: eaffffec b 3218 <rtems_termios_refill_transmitter+0x174> <== NOT EXECUTED
3264: e10f3000 mrs r3, CPSR <== NOT EXECUTED
3268: e3832080 orr r2, r3, #128 ; 0x80 <== NOT EXECUTED
326c: e129f002 msr CPSR_fc, r2 <== NOT EXECUTED
else if ((tty->flow_ctrl & (FL_MDXON | FL_ORCVXOF))
== (FL_MDXON | FL_ORCVXOF)) {
/* Buffer not empty, but output stops due to XOFF */
/* set flag, that output has been stopped */
rtems_interrupt_disable(level);
tty->flow_ctrl |= FL_OSTOP;
3270: e59420b8 ldr r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
3274: e3822020 orr r2, r2, #32 <== NOT EXECUTED
3278: e58420b8 str r2, [r4, #184] ; 0xb8 <== NOT EXECUTED
tty->rawOutBufState = rob_busy; /*apm*/
327c: e3a02001 mov r2, #1 <== NOT EXECUTED
3280: e5842094 str r2, [r4, #148] ; 0x94 <== NOT EXECUTED
static inline void arm_interrupt_enable( uint32_t level )
{
ARM_SWITCH_REGISTERS;
asm volatile (
3284: e129f003 msr CPSR_fc, r3 <== NOT EXECUTED
3288: e3a06000 mov r6, #0 <== NOT EXECUTED
328c: eaffffbe b 318c <rtems_termios_refill_transmitter+0xe8> <== NOT EXECUTED
*/
if (tty->rawOutBufState == rob_wait) {
/*
* this should never happen...
*/
rtems_semaphore_release (tty->rawOutBuf.Semaphore);
3290: e590008c ldr r0, [r0, #140] ; 0x8c <== NOT EXECUTED
3294: eb00098c bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
3298: e3a06000 mov r6, #0 <== NOT EXECUTED
329c: eaffffc1 b 31a8 <rtems_termios_refill_transmitter+0x104> <== NOT EXECUTED
00004d28 <rtems_termios_rxdaemon>:
/*
* this task actually processes any receive events
*/
static rtems_task rtems_termios_rxdaemon(rtems_task_argument argument)
{
4d28: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
4d2c: e24dd008 sub sp, sp, #8 <== NOT EXECUTED
4d30: e1a04000 mov r4, r0 <== NOT EXECUTED
4d34: e28d7007 add r7, sp, #7 <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
4d38: e3a06000 mov r6, #0 <== NOT EXECUTED
4d3c: e1a0300d mov r3, sp <== NOT EXECUTED
4d40: e3a01002 mov r1, #2 <== NOT EXECUTED
4d44: e3a02000 mov r2, #0 <== NOT EXECUTED
4d48: e3a00003 mov r0, #3 <== NOT EXECUTED
4d4c: eb000112 bl 519c <rtems_event_receive> <== NOT EXECUTED
TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
4d50: e59d3000 ldr r3, [sp] <== NOT EXECUTED
4d54: e3130001 tst r3, #1 <== NOT EXECUTED
4d58: 1a000012 bne 4da8 <rtems_termios_rxdaemon+0x80> <== NOT EXECUTED
}
else {
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
4d5c: e5940010 ldr r0, [r4, #16] <== NOT EXECUTED
4d60: e1a0e00f mov lr, pc <== NOT EXECUTED
4d64: e594f0a0 ldr pc, [r4, #160] ; 0xa0 <== NOT EXECUTED
if (c != EOF) {
4d68: e3700001 cmn r0, #1 <== NOT EXECUTED
}
else {
/*
* do something
*/
c = tty->device.pollRead(tty->minor);
4d6c: e1a03000 mov r3, r0 <== NOT EXECUTED
if (c != EOF) {
4d70: 0afffff1 beq 4d3c <rtems_termios_rxdaemon+0x14> <== NOT EXECUTED
/* * pollRead did call enqueue on its own */ c_buf = c; rtems_termios_enqueue_raw_characters (
4d74: e1a01007 mov r1, r7 <== NOT EXECUTED
4d78: e3a02001 mov r2, #1 <== NOT EXECUTED
4d7c: e1a00004 mov r0, r4 <== NOT EXECUTED
c = tty->device.pollRead(tty->minor);
if (c != EOF) {
/*
* pollRead did call enqueue on its own
*/
c_buf = c;
4d80: e5cd3007 strb r3, [sp, #7] <== NOT EXECUTED
rtems_termios_enqueue_raw_characters (
4d84: ebfff95f bl 3308 <rtems_termios_enqueue_raw_characters> <== NOT EXECUTED
char c_buf;
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_RX_PROC_EVENT |
4d88: e1a0300d mov r3, sp <== NOT EXECUTED
4d8c: e3a01002 mov r1, #2 <== NOT EXECUTED
4d90: e3a02000 mov r2, #0 <== NOT EXECUTED
4d94: e3a00003 mov r0, #3 <== NOT EXECUTED
4d98: eb0000ff bl 519c <rtems_event_receive> <== NOT EXECUTED
TERMIOS_RX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_RX_TERMINATE_EVENT) != 0) {
4d9c: e59d3000 ldr r3, [sp] <== NOT EXECUTED
4da0: e3130001 tst r3, #1 <== NOT EXECUTED
4da4: 0affffec beq 4d5c <rtems_termios_rxdaemon+0x34> <== NOT EXECUTED
tty->rxTaskId = 0;
4da8: e58460c4 str r6, [r4, #196] ; 0xc4 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
4dac: e1a00006 mov r0, r6 <== NOT EXECUTED
4db0: eb00033d bl 5aac <rtems_task_delete> <== NOT EXECUTED
4db4: eaffffe0 b 4d3c <rtems_termios_rxdaemon+0x14> <== NOT EXECUTED
00003098 <rtems_termios_rxirq_occured>:
void rtems_termios_rxirq_occured(struct rtems_termios_tty *tty)
{
/*
* send event to rx daemon task
*/
rtems_event_send(tty->rxTaskId,TERMIOS_RX_PROC_EVENT);
3098: e59000c4 ldr r0, [r0, #196] ; 0xc4 <== NOT EXECUTED
309c: e3a01002 mov r1, #2 <== NOT EXECUTED
30a0: ea00089b b 5314 <rtems_event_send> <== NOT EXECUTED
00004cb8 <rtems_termios_txdaemon>:
/*
* this task actually processes any transmit events
*/
static rtems_task rtems_termios_txdaemon(rtems_task_argument argument)
{
4cb8: e92d40f0 push {r4, r5, r6, r7, lr} <== NOT EXECUTED
4cbc: e59f6060 ldr r6, [pc, #96] ; 4d24 <rtems_termios_txdaemon+0x6c><== NOT EXECUTED
4cc0: e24dd004 sub sp, sp, #4 <== NOT EXECUTED
4cc4: e1a04000 mov r4, r0 <== NOT EXECUTED
while (1) {
/*
* wait for rtems event
*/
rtems_event_receive((TERMIOS_TX_START_EVENT |
4cc8: e3a07000 mov r7, #0 <== NOT EXECUTED
4ccc: e1a0300d mov r3, sp <== NOT EXECUTED
4cd0: e3a01002 mov r1, #2 <== NOT EXECUTED
4cd4: e3a02000 mov r2, #0 <== NOT EXECUTED
4cd8: e3a00003 mov r0, #3 <== NOT EXECUTED
4cdc: eb00012e bl 519c <rtems_event_receive> <== NOT EXECUTED
TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
4ce0: e59d3000 ldr r3, [sp] <== NOT EXECUTED
4ce4: e3130001 tst r3, #1 <== NOT EXECUTED
else {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
rtems_termios_linesw[tty->t_line].l_start(tty);
4ce8: e1a00004 mov r0, r4 <== NOT EXECUTED
rtems_event_receive((TERMIOS_TX_START_EVENT |
TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
4cec: 1a000008 bne 4d14 <rtems_termios_txdaemon+0x5c> <== NOT EXECUTED
}
else {
/*
* call any line discipline start function
*/
if (rtems_termios_linesw[tty->t_line].l_start != NULL) {
4cf0: e59430cc ldr r3, [r4, #204] ; 0xcc <== NOT EXECUTED
4cf4: e0863283 add r3, r6, r3, lsl #5 <== NOT EXECUTED
4cf8: e5933014 ldr r3, [r3, #20] <== NOT EXECUTED
4cfc: e3530000 cmp r3, #0 <== NOT EXECUTED
rtems_termios_linesw[tty->t_line].l_start(tty);
4d00: 11a0e00f movne lr, pc <== NOT EXECUTED
4d04: 112fff13 bxne r3 <== NOT EXECUTED
} /* * try to push further characters to device */ rtems_termios_refill_transmitter(tty);
4d08: e1a00004 mov r0, r4 <== NOT EXECUTED
4d0c: ebfff8e4 bl 30a4 <rtems_termios_refill_transmitter> <== NOT EXECUTED
4d10: eaffffed b 4ccc <rtems_termios_txdaemon+0x14> <== NOT EXECUTED
TERMIOS_TX_TERMINATE_EVENT),
RTEMS_EVENT_ANY | RTEMS_WAIT,
RTEMS_NO_TIMEOUT,
&the_event);
if ((the_event & TERMIOS_TX_TERMINATE_EVENT) != 0) {
tty->txTaskId = 0;
4d14: e58470c8 str r7, [r4, #200] ; 0xc8 <== NOT EXECUTED
rtems_task_delete(RTEMS_SELF);
4d18: e1a00007 mov r0, r7 <== NOT EXECUTED
4d1c: eb000362 bl 5aac <rtems_task_delete> <== NOT EXECUTED
4d20: eaffffe9 b 4ccc <rtems_termios_txdaemon+0x14> <== NOT EXECUTED
00003d5c <rtems_termios_write>:
rtems_status_code
rtems_termios_write (void *arg)
{
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
3d5c: e5903000 ldr r3, [r0]
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
3d60: e92d45f0 push {r4, r5, r6, r7, r8, sl, lr}
rtems_libio_rw_args_t *args = arg; struct rtems_termios_tty *tty = args->iop->data1;
3d64: e5934034 ldr r4, [r3, #52] ; 0x34
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3d68: e3a01000 mov r1, #0
rtems_termios_puts (&c, 1, tty);
}
rtems_status_code
rtems_termios_write (void *arg)
{
3d6c: e1a05000 mov r5, r0
rtems_libio_rw_args_t *args = arg;
struct rtems_termios_tty *tty = args->iop->data1;
rtems_status_code sc;
sc = rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3d70: e1a02001 mov r2, r1
3d74: e5940018 ldr r0, [r4, #24]
3d78: eb00068b bl 57ac <rtems_semaphore_obtain>
if (sc != RTEMS_SUCCESSFUL)
3d7c: e2506000 subs r6, r0, #0
3d80: 1a00000c bne 3db8 <rtems_termios_write+0x5c>
return sc;
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
3d84: e59420cc ldr r2, [r4, #204] ; 0xcc
3d88: e59f3098 ldr r3, [pc, #152] ; 3e28 <rtems_termios_write+0xcc>
3d8c: e0833282 add r3, r3, r2, lsl #5
3d90: e593300c ldr r3, [r3, #12]
3d94: e3530000 cmp r3, #0
3d98: 0a000008 beq 3dc0 <rtems_termios_write+0x64>
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
3d9c: e1a01005 mov r1, r5 <== NOT EXECUTED
3da0: e1a00004 mov r0, r4 <== NOT EXECUTED
3da4: e1a0e00f mov lr, pc <== NOT EXECUTED
3da8: e12fff13 bx r3 <== NOT EXECUTED
3dac: e1a06000 mov r6, r0 <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
3db0: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
3db4: eb0006c4 bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
rtems_termios_puts (args->buffer, args->count, tty); args->bytes_moved = args->count; } rtems_semaphore_release (tty->osem); return sc; }
3db8: e1a00006 mov r0, r6 <== NOT EXECUTED
3dbc: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc} <== NOT EXECUTED
if (rtems_termios_linesw[tty->t_line].l_write != NULL) {
sc = rtems_termios_linesw[tty->t_line].l_write(tty,args);
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
3dc0: e5943034 ldr r3, [r4, #52] ; 0x34
3dc4: e3130001 tst r3, #1
3dc8: 0a000011 beq 3e14 <rtems_termios_write+0xb8>
uint32_t count = args->count;
3dcc: e5958010 ldr r8, [r5, #16]
char *buffer = args->buffer; while (count--)
3dd0: e3580000 cmp r8, #0
rtems_semaphore_release (tty->osem);
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
3dd4: e595a00c ldr sl, [r5, #12]
while (count--)
3dd8: 01a03006 moveq r3, r6
3ddc: 0a000007 beq 3e00 <rtems_termios_write+0xa4>
3de0: e1a07006 mov r7, r6
oproc (*buffer++, tty);
3de4: e7da0007 ldrb r0, [sl, r7]
3de8: e1a01004 mov r1, r4
3dec: e2877001 add r7, r7, #1
3df0: ebfffe4d bl 372c <oproc>
return sc;
}
if (tty->termios.c_oflag & OPOST) {
uint32_t count = args->count;
char *buffer = args->buffer;
while (count--)
3df4: e1580007 cmp r8, r7
3df8: 1afffff9 bne 3de4 <rtems_termios_write+0x88>
oproc (*buffer++, tty);
args->bytes_moved = args->count;
}
else {
rtems_termios_puts (args->buffer, args->count, tty);
args->bytes_moved = args->count;
3dfc: e5953010 ldr r3, [r5, #16]
3e00: e5853018 str r3, [r5, #24]
} rtems_semaphore_release (tty->osem);
3e04: e5940018 ldr r0, [r4, #24]
3e08: eb0006af bl 58cc <rtems_semaphore_release>
return sc; }
3e0c: e1a00006 mov r0, r6
3e10: e8bd85f0 pop {r4, r5, r6, r7, r8, sl, pc}
while (count--)
oproc (*buffer++, tty);
args->bytes_moved = args->count;
}
else {
rtems_termios_puts (args->buffer, args->count, tty);
3e14: e285000c add r0, r5, #12 <== NOT EXECUTED
3e18: e8900003 ldm r0, {r0, r1} <== NOT EXECUTED
3e1c: e1a02004 mov r2, r4 <== NOT EXECUTED
3e20: ebfffdf9 bl 360c <rtems_termios_puts> <== NOT EXECUTED
3e24: eafffff4 b 3dfc <rtems_termios_write+0xa0> <== NOT EXECUTED
00006b68 <rtems_verror>:
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
6b68: e92d47f0 push {r4, r5, r6, r7, r8, r9, sl, lr} <== NOT EXECUTED
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC)
6b6c: e2108202 ands r8, r0, #536870912 ; 0x20000000 <== NOT EXECUTED
static int rtems_verror(
rtems_error_code_t error_flag,
const char *printf_format,
va_list arglist
)
{
6b70: e1a04000 mov r4, r0 <== NOT EXECUTED
6b74: e1a09001 mov r9, r1 <== NOT EXECUTED
6b78: e1a07002 mov r7, r2 <== NOT EXECUTED
int local_errno = 0;
int chars_written = 0;
rtems_status_code status;
if (error_flag & RTEMS_ERROR_PANIC)
6b7c: 0a00000c beq 6bb4 <rtems_verror+0x4c> <== NOT EXECUTED
{
if (rtems_panic_in_progress++)
6b80: e59f2160 ldr r2, [pc, #352] ; 6ce8 <rtems_verror+0x180> <== NOT EXECUTED
6b84: e5923000 ldr r3, [r2] <== NOT EXECUTED
6b88: e3530000 cmp r3, #0 <== NOT EXECUTED
6b8c: e2833001 add r3, r3, #1 <== NOT EXECUTED
6b90: e5823000 str r3, [r2] <== NOT EXECUTED
6b94: 0a000004 beq 6bac <rtems_verror+0x44> <== NOT EXECUTED
rtems_fatal_error_occurred( 99 );
}
}
#endif
_Thread_Dispatch_disable_level += 1;
6b98: e59f314c ldr r3, [pc, #332] ; 6cec <rtems_verror+0x184> <== NOT EXECUTED
6b9c: e5931000 ldr r1, [r3] <== NOT EXECUTED
6ba0: e2811001 add r1, r1, #1 <== NOT EXECUTED
6ba4: e5831000 str r1, [r3] <== NOT EXECUTED
RTEMS_COMPILER_MEMORY_BARRIER();
6ba8: e5923000 ldr r3, [r2] <== NOT EXECUTED
_Thread_Disable_dispatch(); /* disable task switches */
/* don't aggravate things */
if (rtems_panic_in_progress > 2)
6bac: e3530002 cmp r3, #2 <== NOT EXECUTED
6bb0: ca00002e bgt 6c70 <rtems_verror+0x108> <== NOT EXECUTED
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
6bb4: e59f5134 ldr r5, [pc, #308] ; 6cf0 <rtems_verror+0x188> <== NOT EXECUTED
6bb8: e5953000 ldr r3, [r5] <== NOT EXECUTED
6bbc: e5930008 ldr r0, [r3, #8] <== NOT EXECUTED
6bc0: eb00342e bl 13c80 <fflush> <== NOT EXECUTED
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
6bc4: e2146101 ands r6, r4, #1073741824 ; 0x40000000 <== NOT EXECUTED
return 0;
}
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
6bc8: e3c4a207 bic sl, r4, #1879048192 ; 0x70000000 <== NOT EXECUTED
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
6bcc: 1a000038 bne 6cb4 <rtems_verror+0x14c> <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
6bd0: e5953000 ldr r3, [r5] <== NOT EXECUTED
6bd4: e1a02007 mov r2, r7 <== NOT EXECUTED
6bd8: e1a01009 mov r1, r9 <== NOT EXECUTED
6bdc: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
6be0: eb004c4c bl 19d18 <vfprintf> <== NOT EXECUTED
if (status)
6be4: e35a0000 cmp sl, #0 <== NOT EXECUTED
#if defined(RTEMS_MULTIPROCESSING)
if (_System_state_Is_multiprocessing)
fprintf(stderr, "[%" PRIu32 "] ", _Configuration_MP_table->node);
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
6be8: e1a07000 mov r7, r0 <== NOT EXECUTED
if (status)
6bec: 1a000025 bne 6c88 <rtems_verror+0x120> <== NOT EXECUTED
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno)
6bf0: e3560000 cmp r6, #0 <== NOT EXECUTED
6bf4: 0a00000b beq 6c28 <rtems_verror+0xc0> <== NOT EXECUTED
{
if ((local_errno > 0) && *strerror(local_errno))
6bf8: da000004 ble 6c10 <rtems_verror+0xa8> <== NOT EXECUTED
6bfc: e1a00006 mov r0, r6 <== NOT EXECUTED
6c00: eb0037ef bl 14bc4 <strerror> <== NOT EXECUTED
6c04: e5d03000 ldrb r3, [r0] <== NOT EXECUTED
6c08: e3530000 cmp r3, #0 <== NOT EXECUTED
6c0c: 1a00002b bne 6cc0 <rtems_verror+0x158> <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
6c10: e5953000 ldr r3, [r5] <== NOT EXECUTED
6c14: e59f10d8 ldr r1, [pc, #216] ; 6cf4 <rtems_verror+0x18c> <== NOT EXECUTED
6c18: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
6c1c: e1a02006 mov r2, r6 <== NOT EXECUTED
6c20: eb0034d4 bl 13f78 <fprintf> <== NOT EXECUTED
6c24: e0877000 add r7, r7, r0 <== NOT EXECUTED
}
chars_written += fprintf(stderr, "\n");
6c28: e5953000 ldr r3, [r5] <== NOT EXECUTED
6c2c: e59f10c4 ldr r1, [pc, #196] ; 6cf8 <rtems_verror+0x190> <== NOT EXECUTED
6c30: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
6c34: eb0034cf bl 13f78 <fprintf> <== NOT EXECUTED
(void) fflush(stderr);
6c38: e5953000 ldr r3, [r5] <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
6c3c: e1a0a000 mov sl, r0 <== NOT EXECUTED
(void) fflush(stderr);
6c40: e593000c ldr r0, [r3, #12] <== NOT EXECUTED
6c44: eb00340d bl 13c80 <fflush> <== NOT EXECUTED
if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))
6c48: e3140203 tst r4, #805306368 ; 0x30000000 <== NOT EXECUTED
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
else
chars_written += fprintf(stderr, " (unknown errno=%d)", local_errno);
}
chars_written += fprintf(stderr, "\n");
6c4c: 008a0007 addeq r0, sl, r7 <== NOT EXECUTED
(void) fflush(stderr);
if (error_flag & (RTEMS_ERROR_PANIC | RTEMS_ERROR_ABORT))
6c50: 08bd87f0 popeq {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
{
if (error_flag & RTEMS_ERROR_PANIC)
6c54: e3580000 cmp r8, #0 <== NOT EXECUTED
6c58: 0a000006 beq 6c78 <rtems_verror+0x110> <== NOT EXECUTED
{
rtems_error(0, "fatal error, exiting");
6c5c: e3a00000 mov r0, #0 <== NOT EXECUTED
6c60: e59f1094 ldr r1, [pc, #148] ; 6cfc <rtems_verror+0x194> <== NOT EXECUTED
6c64: eb000035 bl 6d40 <rtems_error> <== NOT EXECUTED
_exit(local_errno);
6c68: e1a00006 mov r0, r6 <== NOT EXECUTED
6c6c: eb000336 bl 794c <_exit> <== NOT EXECUTED
}
else
{
rtems_error(0, "fatal error, aborting");
abort();
6c70: e3a00000 mov r0, #0 <== NOT EXECUTED
}
}
return chars_written;
}
6c74: e8bd87f0 pop {r4, r5, r6, r7, r8, r9, sl, pc} <== NOT EXECUTED
rtems_error(0, "fatal error, exiting");
_exit(local_errno);
}
else
{
rtems_error(0, "fatal error, aborting");
6c78: e59f1080 ldr r1, [pc, #128] ; 6d00 <rtems_verror+0x198> <== NOT EXECUTED
6c7c: e1a00008 mov r0, r8 <== NOT EXECUTED
6c80: eb00002e bl 6d40 <rtems_error> <== NOT EXECUTED
abort();
6c84: eb003301 bl 13890 <abort> <== NOT EXECUTED
#endif
chars_written += vfprintf(stderr, printf_format, arglist);
if (status)
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
6c88: e59f3060 ldr r3, [pc, #96] ; 6cf0 <rtems_verror+0x188> <== NOT EXECUTED
6c8c: e5933000 ldr r3, [r3] <== NOT EXECUTED
6c90: e1a0000a mov r0, sl <== NOT EXECUTED
6c94: e593a00c ldr sl, [r3, #12] <== NOT EXECUTED
6c98: ebffffae bl 6b58 <rtems_status_text> <== NOT EXECUTED
6c9c: e59f1060 ldr r1, [pc, #96] ; 6d04 <rtems_verror+0x19c> <== NOT EXECUTED
6ca0: e1a02000 mov r2, r0 <== NOT EXECUTED
6ca4: e1a0000a mov r0, sl <== NOT EXECUTED
6ca8: eb0034b2 bl 13f78 <fprintf> <== NOT EXECUTED
6cac: e0877000 add r7, r7, r0 <== NOT EXECUTED
6cb0: eaffffce b 6bf0 <rtems_verror+0x88> <== NOT EXECUTED
(void) fflush(stdout); /* in case stdout/stderr same */
status = error_flag & ~RTEMS_ERROR_MASK;
if (error_flag & RTEMS_ERROR_ERRNO) /* include errno? */
local_errno = errno;
6cb4: eb0032fe bl 138b4 <__errno> <== NOT EXECUTED
6cb8: e5906000 ldr r6, [r0] <== NOT EXECUTED
6cbc: eaffffc3 b 6bd0 <rtems_verror+0x68> <== NOT EXECUTED
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno)
{
if ((local_errno > 0) && *strerror(local_errno))
chars_written += fprintf(stderr, " (errno: %s)", strerror(local_errno));
6cc0: e5953000 ldr r3, [r5] <== NOT EXECUTED
6cc4: e1a00006 mov r0, r6 <== NOT EXECUTED
6cc8: e593a00c ldr sl, [r3, #12] <== NOT EXECUTED
6ccc: eb0037bc bl 14bc4 <strerror> <== NOT EXECUTED
6cd0: e59f1030 ldr r1, [pc, #48] ; 6d08 <rtems_verror+0x1a0> <== NOT EXECUTED
6cd4: e1a02000 mov r2, r0 <== NOT EXECUTED
6cd8: e1a0000a mov r0, sl <== NOT EXECUTED
6cdc: eb0034a5 bl 13f78 <fprintf> <== NOT EXECUTED
6ce0: e0877000 add r7, r7, r0 <== NOT EXECUTED
if (status)
chars_written += fprintf(stderr, " (status: %s)", rtems_status_text(status));
if (local_errno)
{
if ((local_errno > 0) && *strerror(local_errno))
6ce4: eaffffcf b 6c28 <rtems_verror+0xc0> <== NOT EXECUTED
000291e4 <scanInt>:
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
291e4: e92d4ff0 push {r4, r5, r6, r7, r8, r9, sl, fp, lr}
291e8: e3a06000 mov r6, #0
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
291ec: e59f90e8 ldr r9, [pc, #232] ; 292dc <scanInt+0xf8>
limit++;
continue;
}
sign = 1;
}
if (!isdigit(c))
291f0: e59f80e8 ldr r8, [pc, #232] ; 292e0 <scanInt+0xfc>
return 0;
d = c - '0';
if ((i > (limit / 10))
291f4: e59fa0e8 ldr sl, [pc, #232] ; 292e4 <scanInt+0x100>
/*
* Extract an integer value from the database
*/
static int
scanInt(FILE *fp, int *val)
{
291f8: e1a04000 mov r4, r0 291fc: e1a0b001 mov fp, r1 29200: e3e07102 mvn r7, #-2147483648 ; 0x80000000 29204: e1a05006 mov r5, r6
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
29208: e5943004 ldr r3, [r4, #4] 2920c: e2433001 sub r3, r3, #1 29210: e3530000 cmp r3, #0 29214: e5843004 str r3, [r4, #4]
29218: ba00001d blt 29294 <scanInt+0xb0>
2921c: e5943000 ldr r3, [r4] 29220: e4d30001 ldrb r0, [r3], #1
if (c == ':')
29224: e350003a cmp r0, #58 ; 0x3a
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
29228: e5843000 str r3, [r4]
if (c == ':')
2922c: 0a00001d beq 292a8 <scanInt+0xc4>
break;
if (sign == 0) {
29230: e3560000 cmp r6, #0
29234: 1a000004 bne 2924c <scanInt+0x68>
if (c == '-') {
29238: e350002d cmp r0, #45 ; 0x2d
sign = -1;
limit++;
2923c: 02877001 addeq r7, r7, #1 29240: 03e06000 mvneq r6, #0
for (;;) {
c = getc(fp);
if (c == ':')
break;
if (sign == 0) {
if (c == '-') {
29244: 0affffef beq 29208 <scanInt+0x24>
sign = -1;
limit++;
continue;
29248: e3a06001 mov r6, #1
}
sign = 1;
}
if (!isdigit(c))
2924c: e5983000 ldr r3, [r8] 29250: e0833000 add r3, r3, r0 29254: e5d33001 ldrb r3, [r3, #1] 29258: e3130004 tst r3, #4
2925c: 0a00001c beq 292d4 <scanInt+0xf0>
return 0;
d = c - '0';
if ((i > (limit / 10))
29260: e083279a umull r2, r3, sl, r7 29264: e15501a3 cmp r5, r3, lsr #3
29268: 8a000019 bhi 292d4 <scanInt+0xf0>
}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
2926c: e2400030 sub r0, r0, #48 ; 0x30 29270: 11a03105 lslne r3, r5, #2
if ((i > (limit / 10))
29274: 0a000011 beq 292c0 <scanInt+0xdc>
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
29278: e0835005 add r5, r3, r5
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2927c: e5943004 ldr r3, [r4, #4] 29280: e2433001 sub r3, r3, #1 29284: e3530000 cmp r3, #0
return 0;
d = c - '0';
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
29288: e0805085 add r5, r0, r5, lsl #1
unsigned int limit = INT_MAX;
int sign = 0;
int d;
for (;;) {
c = getc(fp);
2928c: e5843004 str r3, [r4, #4]
29290: aaffffe1 bge 2921c <scanInt+0x38>
29294: e5990000 ldr r0, [r9] <== NOT EXECUTED 29298: e1a01004 mov r1, r4 <== NOT EXECUTED 2929c: eb007cd5 bl 485f8 <__srget_r> <== NOT EXECUTED
if (c == ':')
292a0: e350003a cmp r0, #58 ; 0x3a <== NOT EXECUTED 292a4: 1affffe1 bne 29230 <scanInt+0x4c> <== NOT EXECUTED
if ((i > (limit / 10))
|| ((i == (limit / 10)) && (d > (limit % 10))))
return 0;
i = i * 10 + d;
}
if (sign == 0)
292a8: e3560000 cmp r6, #0
292ac: 0a000008 beq 292d4 <scanInt+0xf0>
return 0;
*val = i * sign;
292b0: e0030695 mul r3, r5, r6 292b4: e3a00001 mov r0, #1 292b8: e58b3000 str r3, [fp]
return 1;
292bc: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc}
sign = 1;
}
if (!isdigit(c))
return 0;
d = c - '0';
if ((i > (limit / 10))
292c0: e1a03105 lsl r3, r5, #2 <== NOT EXECUTED 292c4: e0832005 add r2, r3, r5 <== NOT EXECUTED 292c8: e0472082 sub r2, r7, r2, lsl #1 <== NOT EXECUTED 292cc: e1500002 cmp r0, r2 <== NOT EXECUTED 292d0: 9affffe8 bls 29278 <scanInt+0x94> <== NOT EXECUTED
i = i * 10 + d;
}
if (sign == 0)
return 0;
*val = i * sign;
return 1;
292d4: e3a00000 mov r0, #0 <== NOT EXECUTED
}
292d8: e8bd8ff0 pop {r4, r5, r6, r7, r8, r9, sl, fp, pc} <== NOT EXECUTED
000292e8 <scanString>:
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
292e8: e92d41f0 push {r4, r5, r6, r7, r8, lr}
292ec: e1a05002 mov r5, r2
int c;
*name = *bufp;
292f0: e5922000 ldr r2, [r2]
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
292f4: e59d7018 ldr r7, [sp, #24]
int c;
*name = *bufp;
292f8: e5812000 str r2, [r1]
for (;;) {
c = getc(fp);
292fc: e59f60c4 ldr r6, [pc, #196] ; 293c8 <scanString+0xe0>
/*
* Extract a string value from the database
*/
static int
scanString(FILE *fp, char **name, char **bufp, size_t *nleft, int nlFlag)
{
29300: e1a04000 mov r4, r0 29304: e1a08003 mov r8, r3 29308: ea000013 b 2935c <scanString+0x74>
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
2930c: e5943000 ldr r3, [r4] 29310: e4d30001 ldrb r0, [r3], #1
if (c == ':') {
29314: e350003a cmp r0, #58 ; 0x3a
{
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
29318: e5843000 str r3, [r4]
if (c == ':') {
2931c: 0a000018 beq 29384 <scanString+0x9c>
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
29320: e350000a cmp r0, #10
29324: 0a000023 beq 293b8 <scanString+0xd0>
if (!nlFlag)
return 0;
break;
}
if (c == EOF)
29328: e3700001 cmn r0, #1
2932c: 0a000023 beq 293c0 <scanString+0xd8>
return 0;
if (*nleft < 2)
29330: e5983000 ldr r3, [r8] 29334: e3530001 cmp r3, #1
29338: 9a000020 bls 293c0 <scanString+0xd8>
return 0;
**bufp = c;
2933c: e5953000 ldr r3, [r5] 29340: e5c30000 strb r0, [r3]
++(*bufp);
29344: e5952000 ldr r2, [r5]
--(*nleft);
29348: e5983000 ldr r3, [r8]
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
**bufp = c;
++(*bufp);
2934c: e2822001 add r2, r2, #1
--(*nleft);
29350: e2433001 sub r3, r3, #1
if (c == EOF)
return 0;
if (*nleft < 2)
return 0;
**bufp = c;
++(*bufp);
29354: e5852000 str r2, [r5]
--(*nleft);
29358: e5883000 str r3, [r8]
{
int c;
*name = *bufp;
for (;;) {
c = getc(fp);
2935c: e5943004 ldr r3, [r4, #4] 29360: e2433001 sub r3, r3, #1 29364: e3530000 cmp r3, #0 29368: e5843004 str r3, [r4, #4]
2936c: aaffffe6 bge 2930c <scanString+0x24>
29370: e5960000 ldr r0, [r6] 29374: e1a01004 mov r1, r4 29378: eb007c9e bl 485f8 <__srget_r>
if (c == ':') {
2937c: e350003a cmp r0, #58 ; 0x3a
29380: 1affffe6 bne 29320 <scanString+0x38>
if (nlFlag)
29384: e3570000 cmp r7, #0
29388: 1a00000c bne 293c0 <scanString+0xd8>
return 0;
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
2938c: e5953000 ldr r3, [r5] 29390: e3a02000 mov r2, #0 29394: e5c32000 strb r2, [r3]
++(*bufp);
29398: e5952000 ldr r2, [r5]
--(*nleft);
2939c: e5983000 ldr r3, [r8]
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
293a0: e2822001 add r2, r2, #1
--(*nleft);
293a4: e2433001 sub r3, r3, #1
**bufp = c;
++(*bufp);
--(*nleft);
}
**bufp = '\0';
++(*bufp);
293a8: e5852000 str r2, [r5]
--(*nleft);
293ac: e5883000 str r3, [r8] 293b0: e3a00001 mov r0, #1
return 1;
293b4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
if (nlFlag)
return 0;
break;
}
if (c == '\n') {
if (!nlFlag)
293b8: e3570000 cmp r7, #0
293bc: 1afffff2 bne 2938c <scanString+0xa4>
--(*nleft);
}
**bufp = '\0';
++(*bufp);
--(*nleft);
return 1;
293c0: e3a00000 mov r0, #0 <== NOT EXECUTED
}
293c4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc} <== NOT EXECUTED
000293cc <scangr>:
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
293cc: e92d41f0 push {r4, r5, r6, r7, r8, lr}
293d0: e24dd014 sub sp, sp, #20
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
293d4: e28d5008 add r5, sp, #8 293d8: e28d4004 add r4, sp, #4
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
293dc: e58d2008 str r2, [sp, #8] 293e0: e58d3004 str r3, [sp, #4]
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
293e4: e3a06000 mov r6, #0 293e8: e1a02005 mov r2, r5 293ec: e1a03004 mov r3, r4 293f0: e58d6000 str r6, [sp]
FILE *fp,
struct group *grp,
char *buffer,
size_t bufsize
)
{
293f4: e1a07000 mov r7, r0 293f8: e1a08001 mov r8, r1
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
293fc: ebffffb9 bl 292e8 <scanString> 29400: e1500006 cmp r0, r6
29404: 1a000002 bne 29414 <scangr+0x48>
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
return 1;
29408: e3a00000 mov r0, #0 <== NOT EXECUTED
}
2940c: e28dd014 add sp, sp, #20
29410: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
29414: e1a00007 mov r0, r7 29418: e2881004 add r1, r8, #4 2941c: e1a02005 mov r2, r5 29420: e1a03004 mov r3, r4 29424: e58d6000 str r6, [sp] 29428: ebffffae bl 292e8 <scanString>
{
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
2942c: e1500006 cmp r0, r6
29430: 0afffff4 beq 29408 <scangr+0x3c> || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &grgid)
29434: e1a00007 mov r0, r7 29438: e28d1010 add r1, sp, #16 2943c: ebffff68 bl 291e4 <scanInt>
{
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
29440: e1500006 cmp r0, r6
29444: 0affffef beq 29408 <scangr+0x3c> || !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &grgid) || !scanString(fp, &grmem, &buffer, &bufsize, 1))
29448: e1a03004 mov r3, r4 2944c: e1a00007 mov r0, r7 29450: e1a02005 mov r2, r5 29454: e3a04001 mov r4, #1 29458: e28d100c add r1, sp, #12 2945c: e58d4000 str r4, [sp] 29460: ebffffa0 bl 292e8 <scanString>
{
int grgid;
char *grmem, *cp;
int memcount;
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
29464: e1500006 cmp r0, r6
29468: 0affffe6 beq 29408 <scangr+0x3c>
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
grp->gr_gid = grgid;
2946c: e1dd31b0 ldrh r3, [sp, #16]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
29470: e59d100c ldr r1, [sp, #12]
if (!scanString(fp, &grp->gr_name, &buffer, &bufsize, 0)
|| !scanString(fp, &grp->gr_passwd, &buffer, &bufsize, 0)
|| !scanInt(fp, &grgid)
|| !scanString(fp, &grmem, &buffer, &bufsize, 1))
return 0;
grp->gr_gid = grgid;
29474: e1c830b8 strh r3, [r8, #8]
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
29478: e5d13000 ldrb r3, [r1] 2947c: e1530006 cmp r3, r6 29480: 03a04017 moveq r4, #23
29484: 0a000007 beq 294a8 <scangr+0xdc>
29488: e1a02001 mov r2, r1
if(*cp == ',')
2948c: e353002c cmp r3, #44 ; 0x2c
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
29490: e5f23001 ldrb r3, [r2, #1]!
if(*cp == ',')
memcount++;
29494: 02844001 addeq r4, r4, #1
grp->gr_gid = grgid;
/*
* Determine number of members
*/
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
29498: e3530000 cmp r3, #0
2949c: 1afffffa bne 2948c <scangr+0xc0>
294a0: e1a04104 lsl r4, r4, #2 294a4: e2844013 add r4, r4, #19
}
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
294a8: e59d3004 ldr r3, [sp, #4] 294ac: e1530004 cmp r3, r4
294b0: 3affffd4 bcc 29408 <scangr+0x3c>
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
294b4: e59d3008 ldr r3, [sp, #8] 294b8: e283300f add r3, r3, #15 294bc: e3c3300f bic r3, r3, #15
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
294c0: e5831000 str r1, [r3]
/*
* Hack to produce (hopefully) a suitably-aligned array of pointers
*/
if (bufsize < (((memcount+1)*sizeof(char *)) + 15))
return 0;
grp->gr_mem = (char **)(((uintptr_t)buffer + 15) & ~15);
294c4: e588300c str r3, [r8, #12]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
294c8: e59d200c ldr r2, [sp, #12] 294cc: e5d23000 ldrb r3, [r2] 294d0: e3530000 cmp r3, #0 294d4: 03a01004 moveq r1, #4
294d8: 0a00000b beq 2950c <scangr+0x140>
294dc: e2822001 add r2, r2, #1 294e0: e3a01001 mov r1, #1
if(*cp == ',') {
*cp = '\0';
294e4: e3a00000 mov r0, #0
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
if(*cp == ',') {
294e8: e353002c cmp r3, #44 ; 0x2c
*cp = '\0';
294ec: 05420001 strbeq r0, [r2, #-1]
grp->gr_mem[memcount++] = cp + 1;
294f0: 0598300c ldreq r3, [r8, #12] 294f4: 07832101 streq r2, [r3, r1, lsl #2]
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
294f8: e4d23001 ldrb r3, [r2], #1
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
294fc: 02811001 addeq r1, r1, #1
/*
* Fill in pointer array
*/
grp->gr_mem[0] = grmem;
for (cp = grmem, memcount = 1 ; *cp != 0 ; cp++) {
29500: e3530000 cmp r3, #0
29504: 1afffff7 bne 294e8 <scangr+0x11c>
29508: e1a01101 lsl r1, r1, #2
if(*cp == ',') {
*cp = '\0';
grp->gr_mem[memcount++] = cp + 1;
}
}
grp->gr_mem[memcount] = NULL;
2950c: e598300c ldr r3, [r8, #12] 29510: e3a02000 mov r2, #0 29514: e7832001 str r2, [r3, r1] 29518: e3a00001 mov r0, #1
return 1;
2951c: eaffffba b 2940c <scangr+0x40>
00029560 <scanpw>:
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
29560: e92d41f0 push {r4, r5, r6, r7, r8, lr}
29564: e24dd014 sub sp, sp, #20
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
29568: e28d5008 add r5, sp, #8 2956c: e28d4004 add r4, sp, #4
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
29570: e58d2008 str r2, [sp, #8] 29574: e58d3004 str r3, [sp, #4]
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
29578: e3a06000 mov r6, #0 2957c: e1a02005 mov r2, r5 29580: e1a03004 mov r3, r4 29584: e58d6000 str r6, [sp]
FILE *fp,
struct passwd *pwd,
char *buffer,
size_t bufsize
)
{
29588: e1a07000 mov r7, r0 2958c: e1a08001 mov r8, r1
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
29590: ebffff54 bl 292e8 <scanString> 29594: e1500006 cmp r0, r6
29598: 1a000002 bne 295a8 <scanpw+0x48>
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
return 1;
2959c: e3a00000 mov r0, #0 <== NOT EXECUTED
}
295a0: e28dd014 add sp, sp, #20
295a4: e8bd81f0 pop {r4, r5, r6, r7, r8, pc}
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0)
295a8: e1a00007 mov r0, r7 295ac: e2881004 add r1, r8, #4 295b0: e1a02005 mov r2, r5 295b4: e1a03004 mov r3, r4 295b8: e58d6000 str r6, [sp] 295bc: ebffff49 bl 292e8 <scanString>
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
295c0: e1500006 cmp r0, r6
295c4: 0afffff4 beq 2959c <scanpw+0x3c> || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &pwuid)
295c8: e1a00007 mov r0, r7 295cc: e28d1010 add r1, sp, #16 295d0: ebffff03 bl 291e4 <scanInt>
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
295d4: e1500006 cmp r0, r6
295d8: 0affffef beq 2959c <scanpw+0x3c> || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &pwuid) || !scanInt(fp, &pwgid)
295dc: e1a00007 mov r0, r7 295e0: e28d100c add r1, sp, #12 295e4: ebfffefe bl 291e4 <scanInt>
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
295e8: e1500006 cmp r0, r6
295ec: 0affffea beq 2959c <scanpw+0x3c> || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &pwuid) || !scanInt(fp, &pwgid) || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
295f0: e1a00007 mov r0, r7 295f4: e288100c add r1, r8, #12 295f8: e1a02005 mov r2, r5 295fc: e1a03004 mov r3, r4 29600: e58d6000 str r6, [sp] 29604: ebffff37 bl 292e8 <scanString>
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
29608: e1500006 cmp r0, r6
2960c: 0affffe2 beq 2959c <scanpw+0x3c> || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &pwuid) || !scanInt(fp, &pwgid) || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
29610: e1a00007 mov r0, r7 29614: e2881010 add r1, r8, #16 29618: e1a02005 mov r2, r5 2961c: e1a03004 mov r3, r4 29620: e58d6000 str r6, [sp] 29624: ebffff2f bl 292e8 <scanString>
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
29628: e1500006 cmp r0, r6
2962c: 0affffda beq 2959c <scanpw+0x3c> || !scanString(fp, &pwd->pw_passwd, &buffer, &bufsize, 0) || !scanInt(fp, &pwuid) || !scanInt(fp, &pwgid) || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
29630: e1a00007 mov r0, r7 29634: e2881014 add r1, r8, #20 29638: e1a02005 mov r2, r5 2963c: e1a03004 mov r3, r4 29640: e58d6000 str r6, [sp] 29644: ebffff27 bl 292e8 <scanString>
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
29648: e1500006 cmp r0, r6
2964c: 0affffd2 beq 2959c <scanpw+0x3c> || !scanInt(fp, &pwuid) || !scanInt(fp, &pwgid) || !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0) || !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
29650: e1a03004 mov r3, r4 29654: e1a00007 mov r0, r7 29658: e1a02005 mov r2, r5 2965c: e3a04001 mov r4, #1 29660: e2881018 add r1, r8, #24 29664: e58d4000 str r4, [sp] 29668: ebffff1e bl 292e8 <scanString>
size_t bufsize
)
{
int pwuid, pwgid;
if (!scanString(fp, &pwd->pw_name, &buffer, &bufsize, 0)
2966c: e1500006 cmp r0, r6
29670: 0affffc9 beq 2959c <scanpw+0x3c>
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
pwd->pw_uid = pwuid;
pwd->pw_gid = pwgid;
29674: e1dd30bc ldrh r3, [sp, #12] 29678: e1c830ba strh r3, [r8, #10]
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
pwd->pw_uid = pwuid;
2967c: e1dd31b0 ldrh r3, [sp, #16]
pwd->pw_gid = pwgid;
29680: e1a00004 mov r0, r4
|| !scanString(fp, &pwd->pw_comment, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_gecos, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_dir, &buffer, &bufsize, 0)
|| !scanString(fp, &pwd->pw_shell, &buffer, &bufsize, 1))
return 0;
pwd->pw_uid = pwuid;
29684: e1c830b8 strh r3, [r8, #8]
pwd->pw_gid = pwgid; return 1;
29688: eaffffc4 b 295a0 <scanpw+0x40>
0002919c <setgid>:
int setgid(
gid_t gid
)
{
_POSIX_types_Gid = gid;
2919c: e59f300c ldr r3, [pc, #12] ; 291b0 <setgid+0x14> <== NOT EXECUTED 291a0: e5933000 ldr r3, [r3] <== NOT EXECUTED 291a4: e1c303b4 strh r0, [r3, #52] ; 0x34 <== NOT EXECUTED
return 0; }
291a8: e3a00000 mov r0, #0 <== NOT EXECUTED 291ac: e12fff1e bx lr <== NOT EXECUTED
000297ac <setgrent>:
return NULL;
return &grent;
}
void setgrent(void)
{
297ac: e92d4010 push {r4, lr} <== NOT EXECUTED
init_etc_passwd_group();
if (group_fp != NULL)
297b0: e59f4020 ldr r4, [pc, #32] ; 297d8 <setgrent+0x2c> <== NOT EXECUTED
return &grent;
}
void setgrent(void)
{
init_etc_passwd_group();
297b4: ebffffc4 bl 296cc <init_etc_passwd_group> <== NOT EXECUTED
if (group_fp != NULL)
297b8: e5940000 ldr r0, [r4] <== NOT EXECUTED 297bc: e3500000 cmp r0, #0 <== NOT EXECUTED
fclose(group_fp);
297c0: 1b006657 blne 43124 <fclose> <== NOT EXECUTED
group_fp = fopen("/etc/group", "r");
297c4: e59f0010 ldr r0, [pc, #16] ; 297dc <setgrent+0x30> <== NOT EXECUTED 297c8: e59f1010 ldr r1, [pc, #16] ; 297e0 <setgrent+0x34> <== NOT EXECUTED 297cc: eb006877 bl 439b0 <fopen> <== NOT EXECUTED 297d0: e5840000 str r0, [r4] <== NOT EXECUTED
}
297d4: e8bd8010 pop {r4, pc} <== NOT EXECUTED
000299a4 <setpwent>:
return NULL;
return &pwent;
}
void setpwent(void)
{
299a4: e92d4010 push {r4, lr} <== NOT EXECUTED
init_etc_passwd_group();
if (passwd_fp != NULL)
299a8: e59f4020 ldr r4, [pc, #32] ; 299d0 <setpwent+0x2c> <== NOT EXECUTED
return &pwent;
}
void setpwent(void)
{
init_etc_passwd_group();
299ac: ebffff46 bl 296cc <init_etc_passwd_group> <== NOT EXECUTED
if (passwd_fp != NULL)
299b0: e5940004 ldr r0, [r4, #4] <== NOT EXECUTED 299b4: e3500000 cmp r0, #0 <== NOT EXECUTED
fclose(passwd_fp);
299b8: 1b0065d9 blne 43124 <fclose> <== NOT EXECUTED
passwd_fp = fopen("/etc/passwd", "r");
299bc: e59f0010 ldr r0, [pc, #16] ; 299d4 <setpwent+0x30> <== NOT EXECUTED 299c0: e59f1010 ldr r1, [pc, #16] ; 299d8 <setpwent+0x34> <== NOT EXECUTED 299c4: eb0067f9 bl 439b0 <fopen> <== NOT EXECUTED 299c8: e5840004 str r0, [r4, #4] <== NOT EXECUTED
}
299cc: e8bd8010 pop {r4, pc} <== NOT EXECUTED
00007ea0 <setuid>:
int setuid(
uid_t uid
)
{
_POSIX_types_Uid = uid;
7ea0: e59f300c ldr r3, [pc, #12] ; 7eb4 <setuid+0x14> <== NOT EXECUTED
7ea4: e5933000 ldr r3, [r3] <== NOT EXECUTED
7ea8: e1c303b2 strh r0, [r3, #50] ; 0x32 <== NOT EXECUTED
return 0; }
7eac: e3a00000 mov r0, #0 <== NOT EXECUTED
7eb0: e12fff1e bx lr <== NOT EXECUTED
00003cf8 <siproc>:
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
3cf8: e591303c ldr r3, [r1, #60] ; 0x3c <== NOT EXECUTED
3cfc: e3c33f61 bic r3, r3, #388 ; 0x184 <== NOT EXECUTED
3d00: e3c33003 bic r3, r3, #3 <== NOT EXECUTED
3d04: e1a03a03 lsl r3, r3, #20 <== NOT EXECUTED
3d08: e1a03a23 lsr r3, r3, #20 <== NOT EXECUTED
3d0c: e3530000 cmp r3, #0 <== NOT EXECUTED
/*
* Process input character, with semaphore.
*/
static int
siproc (unsigned char c, struct rtems_termios_tty *tty)
{
3d10: e92d4030 push {r4, r5, lr} <== NOT EXECUTED
3d14: e1a04001 mov r4, r1 <== NOT EXECUTED
3d18: e20050ff and r5, r0, #255 ; 0xff <== NOT EXECUTED
int i;
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
3d1c: 1a000002 bne 3d2c <siproc+0x34> <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
3d20: e1a00005 mov r0, r5 <== NOT EXECUTED
} return i; }
3d24: e8bd4030 pop {r4, r5, lr} <== NOT EXECUTED
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
i = iproc (c, tty);
rtems_semaphore_release (tty->osem);
}
else {
i = iproc (c, tty);
3d28: eaffff80 b 3b30 <iproc> <== NOT EXECUTED
/*
* Obtain output semaphore if character will be echoed
*/
if (tty->termios.c_lflag & (ECHO|ECHOE|ECHOK|ECHONL|ECHOPRT|ECHOCTL|ECHOKE)) {
rtems_semaphore_obtain (tty->osem, RTEMS_WAIT, RTEMS_NO_TIMEOUT);
3d2c: e3a01000 mov r1, #0 <== NOT EXECUTED
3d30: e1a02001 mov r2, r1 <== NOT EXECUTED
3d34: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
3d38: eb00069b bl 57ac <rtems_semaphore_obtain> <== NOT EXECUTED
i = iproc (c, tty);
3d3c: e1a01004 mov r1, r4 <== NOT EXECUTED
3d40: e1a00005 mov r0, r5 <== NOT EXECUTED
3d44: ebffff79 bl 3b30 <iproc> <== NOT EXECUTED
3d48: e1a05000 mov r5, r0 <== NOT EXECUTED
rtems_semaphore_release (tty->osem);
3d4c: e5940018 ldr r0, [r4, #24] <== NOT EXECUTED
3d50: eb0006dd bl 58cc <rtems_semaphore_release> <== NOT EXECUTED
}
else {
i = iproc (c, tty);
}
return i;
}
3d54: e1a00005 mov r0, r5 <== NOT EXECUTED
3d58: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
00009638 <stat>:
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
9638: e92d4070 push {r4, r5, r6, lr}
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
963c: e2515000 subs r5, r1, #0
int _STAT_NAME(
const char *path,
struct stat *buf
)
{
9640: e24dd018 sub sp, sp, #24
9644: e1a06000 mov r6, r0
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
9648: 0a00002f beq 970c <stat+0xd4>
rtems_set_errno_and_return_minus_one( EFAULT );
status = rtems_filesystem_evaluate_path( path, strlen( path ),
964c: eb010164 bl 49be4 <strlen>
9650: e28d4004 add r4, sp, #4
9654: e1a01000 mov r1, r0
9658: e3a0c001 mov ip, #1
965c: e1a00006 mov r0, r6
9660: e3a02000 mov r2, #0
9664: e1a03004 mov r3, r4
9668: e58dc000 str ip, [sp]
966c: ebfff99d bl 7ce8 <rtems_filesystem_evaluate_path>
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
9670: e2501000 subs r1, r0, #0
9674: 1a000022 bne 9704 <stat+0xcc>
return -1;
if ( !loc.handlers->fstat_h ){
9678: e59d300c ldr r3, [sp, #12]
967c: e5933018 ldr r3, [r3, #24]
9680: e3530000 cmp r3, #0
9684: 0a000013 beq 96d8 <stat+0xa0>
/*
* Zero out the stat structure so the various support
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
9688: e3a02048 mov r2, #72 ; 0x48
968c: e1a00005 mov r0, r5
9690: eb00f38d bl 464cc <memset>
status = (*loc.handlers->fstat_h)( &loc, buf );
9694: e1a01005 mov r1, r5
9698: e59d300c ldr r3, [sp, #12]
969c: e1a00004 mov r0, r4
96a0: e1a0e00f mov lr, pc
96a4: e593f018 ldr pc, [r3, #24]
rtems_filesystem_freenode( &loc );
96a8: e59d3010 ldr r3, [sp, #16]
96ac: e3530000 cmp r3, #0
* versions of stat don't have to.
*/
memset( buf, 0, sizeof(struct stat) );
status = (*loc.handlers->fstat_h)( &loc, buf );
96b0: e1a05000 mov r5, r0
rtems_filesystem_freenode( &loc );
96b4: 0a000004 beq 96cc <stat+0x94>
96b8: e593301c ldr r3, [r3, #28]
96bc: e3530000 cmp r3, #0
96c0: 11a00004 movne r0, r4
96c4: 11a0e00f movne lr, pc
96c8: 112fff13 bxne r3
return status;
}
96cc: e1a00005 mov r0, r5
96d0: e28dd018 add sp, sp, #24
96d4: e8bd8070 pop {r4, r5, r6, pc}
0, &loc, _STAT_FOLLOW_LINKS );
if ( status != 0 )
return -1;
if ( !loc.handlers->fstat_h ){
rtems_filesystem_freenode( &loc );
96d8: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED
96dc: e3530000 cmp r3, #0 <== NOT EXECUTED
96e0: 0a000004 beq 96f8 <stat+0xc0> <== NOT EXECUTED
96e4: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
96e8: e3530000 cmp r3, #0 <== NOT EXECUTED
96ec: 11a00004 movne r0, r4 <== NOT EXECUTED
96f0: 11a0e00f movne lr, pc <== NOT EXECUTED
96f4: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
96f8: eb00e63c bl 42ff0 <__errno> <== NOT EXECUTED
96fc: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
9700: e5803000 str r3, [r0] <== NOT EXECUTED
9704: e3e05000 mvn r5, #0
9708: eaffffef b 96cc <stat+0x94>
/*
* Check to see if we were passed a valid pointer.
*/
if ( !buf )
rtems_set_errno_and_return_minus_one( EFAULT );
970c: eb00e637 bl 42ff0 <__errno>
9710: e3a0300e mov r3, #14
9714: e5803000 str r3, [r0]
9718: e3e05000 mvn r5, #0
971c: eaffffea b 96cc <stat+0x94>
0002a9a4 <statvfs>:
#include <sys/statvfs.h>
int
statvfs (const char *path, struct statvfs *sb)
{
2a9a4: e92d4070 push {r4, r5, r6, lr} <== NOT EXECUTED
2a9a8: e24dd018 sub sp, sp, #24 <== NOT EXECUTED
2a9ac: e1a04001 mov r4, r1 <== NOT EXECUTED
2a9b0: e1a06000 mov r6, r0 <== NOT EXECUTED
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
2a9b4: eb007c8a bl 49be4 <strlen> <== NOT EXECUTED 2a9b8: e28d5004 add r5, sp, #4 <== NOT EXECUTED 2a9bc: e1a01000 mov r1, r0 <== NOT EXECUTED 2a9c0: e3a0c001 mov ip, #1 <== NOT EXECUTED 2a9c4: e1a00006 mov r0, r6 <== NOT EXECUTED 2a9c8: e3a02000 mov r2, #0 <== NOT EXECUTED 2a9cc: e1a03005 mov r3, r5 <== NOT EXECUTED 2a9d0: e58dc000 str ip, [sp] <== NOT EXECUTED 2a9d4: ebff74c3 bl 7ce8 <rtems_filesystem_evaluate_path> <== NOT EXECUTED 2a9d8: e3500000 cmp r0, #0 <== NOT EXECUTED 2a9dc: 1a000028 bne 2aa84 <statvfs+0xe0> <== NOT EXECUTED
return -1;
mt_entry = loc.mt_entry;
2a9e0: e59d3014 ldr r3, [sp, #20] <== NOT EXECUTED
fs_mount_root = &mt_entry->mt_fs_root;
2a9e4: e5932028 ldr r2, [r3, #40] ; 0x28 <== NOT EXECUTED 2a9e8: e5922044 ldr r2, [r2, #68] ; 0x44 <== NOT EXECUTED 2a9ec: e3520000 cmp r2, #0 <== NOT EXECUTED 2a9f0: 0a000020 beq 2aa78 <statvfs+0xd4> <== NOT EXECUTED
if ( !fs_mount_root->ops->statvfs_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
memset (sb, 0, sizeof (struct statvfs));
2a9f4: e1a02004 mov r2, r4 <== NOT EXECUTED 2a9f8: e4820004 str r0, [r2], #4 <== NOT EXECUTED 2a9fc: e2822004 add r2, r2, #4 <== NOT EXECUTED 2aa00: e5840004 str r0, [r4, #4] <== NOT EXECUTED 2aa04: e4820004 str r0, [r2], #4 <== NOT EXECUTED 2aa08: e4820004 str r0, [r2], #4 <== NOT EXECUTED 2aa0c: e4820004 str r0, [r2], #4 <== NOT EXECUTED 2aa10: e4820004 str r0, [r2], #4 <== NOT EXECUTED 2aa14: e4820004 str r0, [r2], #4 <== NOT EXECUTED 2aa18: e4820004 str r0, [r2], #4 <== NOT EXECUTED 2aa1c: e4820004 str r0, [r2], #4 <== NOT EXECUTED 2aa20: e4820004 str r0, [r2], #4 <== NOT EXECUTED 2aa24: e4820004 str r0, [r2], #4 <== NOT EXECUTED 2aa28: e4820004 str r0, [r2], #4 <== NOT EXECUTED 2aa2c: e4820004 str r0, [r2], #4 <== NOT EXECUTED 2aa30: e5820000 str r0, [r2] <== NOT EXECUTED
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
2aa34: e1a01004 mov r1, r4 <== NOT EXECUTED 2aa38: e283001c add r0, r3, #28 <== NOT EXECUTED 2aa3c: e5933028 ldr r3, [r3, #40] ; 0x28 <== NOT EXECUTED 2aa40: e1a0e00f mov lr, pc <== NOT EXECUTED 2aa44: e593f044 ldr pc, [r3, #68] ; 0x44 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
2aa48: e59d3010 ldr r3, [sp, #16] <== NOT EXECUTED 2aa4c: e3530000 cmp r3, #0 <== NOT EXECUTED
if ( !fs_mount_root->ops->statvfs_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
memset (sb, 0, sizeof (struct statvfs));
result = ( fs_mount_root->ops->statvfs_h )( fs_mount_root, sb );
2aa50: e1a04000 mov r4, r0 <== NOT EXECUTED
rtems_filesystem_freenode( &loc );
2aa54: 0a000004 beq 2aa6c <statvfs+0xc8> <== NOT EXECUTED 2aa58: e593301c ldr r3, [r3, #28] <== NOT EXECUTED 2aa5c: e3530000 cmp r3, #0 <== NOT EXECUTED 2aa60: 11a00005 movne r0, r5 <== NOT EXECUTED 2aa64: 11a0e00f movne lr, pc <== NOT EXECUTED 2aa68: 112fff13 bxne r3 <== NOT EXECUTED
return result;
}
2aa6c: e1a00004 mov r0, r4 <== NOT EXECUTED
2aa70: e28dd018 add sp, sp, #24 <== NOT EXECUTED
2aa74: e8bd8070 pop {r4, r5, r6, pc} <== NOT EXECUTED
mt_entry = loc.mt_entry;
fs_mount_root = &mt_entry->mt_fs_root;
if ( !fs_mount_root->ops->statvfs_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
2aa78: eb00615c bl 42ff0 <__errno> <== NOT EXECUTED 2aa7c: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 2aa80: e5803000 str r3, [r0] <== NOT EXECUTED 2aa84: e3e04000 mvn r4, #0 <== NOT EXECUTED 2aa88: eafffff7 b 2aa6c <statvfs+0xc8> <== NOT EXECUTED
0002aad8 <symlink>:
int symlink(
const char *actualpath,
const char *sympath
)
{
2aad8: e92d4070 push {r4, r5, r6, lr}
2aadc: e1a05001 mov r5, r1
2aae0: e24dd01c sub sp, sp, #28
2aae4: e1a06000 mov r6, r0
rtems_filesystem_location_info_t loc;
int i;
const char *name_start;
int result;
rtems_filesystem_get_start_loc( sympath, &i, &loc );
2aae8: e28d1018 add r1, sp, #24 2aaec: e1a00005 mov r0, r5 2aaf0: e1a0200d mov r2, sp 2aaf4: ebff7b0c bl 972c <rtems_filesystem_get_start_loc>
if ( !loc.ops->evalformake_h ) {
2aaf8: e59d300c ldr r3, [sp, #12] 2aafc: e5933004 ldr r3, [r3, #4] 2ab00: e3530000 cmp r3, #0
rtems_filesystem_location_info_t loc;
int i;
const char *name_start;
int result;
rtems_filesystem_get_start_loc( sympath, &i, &loc );
2ab04: e1a0400d mov r4, sp
if ( !loc.ops->evalformake_h ) {
2ab08: 0a000021 beq 2ab94 <symlink+0xbc>
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start );
2ab0c: e59d0018 ldr r0, [sp, #24] 2ab10: e1a0100d mov r1, sp 2ab14: e0850000 add r0, r5, r0 2ab18: e28d2014 add r2, sp, #20 2ab1c: e1a0e00f mov lr, pc 2ab20: e12fff13 bx r3
if ( result != 0 )
2ab24: e3500000 cmp r0, #0
2ab28: 1a00001c bne 2aba0 <symlink+0xc8>
return -1;
if ( !loc.ops->symlink_h ) {
2ab2c: e59d200c ldr r2, [sp, #12] 2ab30: e5923038 ldr r3, [r2, #56] ; 0x38 2ab34: e3530000 cmp r3, #0
2ab38: 0a000010 beq 2ab80 <symlink+0xa8>
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.ops->symlink_h)( &loc, actualpath, name_start);
2ab3c: e1a01006 mov r1, r6 2ab40: e1a0000d mov r0, sp 2ab44: e59d2014 ldr r2, [sp, #20] 2ab48: e1a0e00f mov lr, pc 2ab4c: e12fff13 bx r3
rtems_filesystem_freenode( &loc );
2ab50: e59d300c ldr r3, [sp, #12] 2ab54: e3530000 cmp r3, #0
if ( !loc.ops->symlink_h ) {
rtems_filesystem_freenode( &loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.ops->symlink_h)( &loc, actualpath, name_start);
2ab58: e1a05000 mov r5, r0
rtems_filesystem_freenode( &loc );
2ab5c: 0a000004 beq 2ab74 <symlink+0x9c>
2ab60: e593301c ldr r3, [r3, #28] 2ab64: e3530000 cmp r3, #0 2ab68: 11a0000d movne r0, sp 2ab6c: 11a0e00f movne lr, pc 2ab70: 112fff13 bxne r3
return result;
}
2ab74: e1a00005 mov r0, r5
2ab78: e28dd01c add sp, sp, #28
2ab7c: e8bd8070 pop {r4, r5, r6, pc}
result = (*loc.ops->evalformake_h)( &sympath[i], &loc, &name_start );
if ( result != 0 )
return -1;
if ( !loc.ops->symlink_h ) {
rtems_filesystem_freenode( &loc );
2ab80: e592301c ldr r3, [r2, #28] <== NOT EXECUTED 2ab84: e3530000 cmp r3, #0 <== NOT EXECUTED 2ab88: 11a0000d movne r0, sp <== NOT EXECUTED 2ab8c: 11a0e00f movne lr, pc <== NOT EXECUTED 2ab90: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
2ab94: eb006115 bl 42ff0 <__errno> <== NOT EXECUTED 2ab98: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 2ab9c: e5803000 str r3, [r0] <== NOT EXECUTED
2aba0: e3e05000 mvn r5, #0 2aba4: eafffff2 b 2ab74 <symlink+0x9c>
00013464 <tcsetattr>:
int fd,
int opt,
struct termios *tp
)
{
switch (opt) {
13464: e3510000 cmp r1, #0
int tcsetattr(
int fd,
int opt,
struct termios *tp
)
{
13468: e92d4030 push {r4, r5, lr}
1346c: e1a04002 mov r4, r2
13470: e1a05000 mov r5, r0
switch (opt) {
13474: 0a00000b beq 134a8 <tcsetattr+0x44>
13478: e3510001 cmp r1, #1 <== NOT EXECUTED 1347c: 0a000004 beq 13494 <tcsetattr+0x30> <== NOT EXECUTED
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
13480: eb001178 bl 17a68 <__errno> <== NOT EXECUTED 13484: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 13488: e5803000 str r3, [r0] <== NOT EXECUTED
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
}
}
1348c: e3e00000 mvn r0, #0 <== NOT EXECUTED
13490: e8bd8030 pop {r4, r5, pc} <== NOT EXECUTED
switch (opt) {
default:
rtems_set_errno_and_return_minus_one( ENOTSUP );
case TCSADRAIN:
if (ioctl( fd, RTEMS_IO_TCDRAIN, NULL ) < 0)
13494: e3a01003 mov r1, #3 <== NOT EXECUTED 13498: e3a02000 mov r2, #0 <== NOT EXECUTED 1349c: eb000f46 bl 171bc <ioctl> <== NOT EXECUTED 134a0: e3500000 cmp r0, #0 <== NOT EXECUTED 134a4: bafffff8 blt 1348c <tcsetattr+0x28> <== NOT EXECUTED
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
134a8: e1a00005 mov r0, r5 134ac: e1a02004 mov r2, r4 134b0: e3a01002 mov r1, #2
} }
134b4: e8bd4030 pop {r4, r5, lr}
return -1;
/*
* Fall through to....
*/
case TCSANOW:
return ioctl( fd, RTEMS_IO_SET_ATTRIBUTES, tp );
134b8: ea000f3f b 171bc <ioctl>
0000db2c <unlink>:
#include <rtems/seterr.h>
int unlink(
const char *path
)
{
db2c: e92d40f0 push {r4, r5, r6, r7, lr}
db30: e24dd030 sub sp, sp, #48 ; 0x30
db34: e1a07000 mov r7, r0
/*
* Get the node to be unlinked. Find the parent path first.
*/
parentpathlen = rtems_filesystem_dirname ( path );
db38: ebffd0eb bl 1eec <rtems_filesystem_dirname>
if ( parentpathlen == 0 )
db3c: e2505000 subs r5, r0, #0
db40: 1a000045 bne dc5c <unlink+0x130>
rtems_filesystem_get_start_loc( path, &i, &parentloc );
db44: e28d4018 add r4, sp, #24
db48: e1a00007 mov r0, r7
db4c: e28d102c add r1, sp, #44 ; 0x2c
db50: e1a02004 mov r2, r4
db54: ebffd515 bl 2fb0 <rtems_filesystem_get_start_loc>
db58: e1a06005 mov r6, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
db5c: e1a0e004 mov lr, r4
db60: e8be000f ldm lr!, {r0, r1, r2, r3}
db64: e28dc004 add ip, sp, #4
db68: e8ac000f stmia ip!, {r0, r1, r2, r3}
db6c: e59e3000 ldr r3, [lr]
name = path + parentpathlen;
db70: e0875005 add r5, r7, r5
/*
* Start from the parent to find the node that should be under it.
*/
loc = parentloc;
db74: e58c3000 str r3, [ip]
name = path + parentpathlen; name += rtems_filesystem_prefix_separators( name, strlen( name ) );
db78: e1a00005 mov r0, r5
db7c: eb0005d4 bl f2d4 <strlen>
db80: e1a01000 mov r1, r0
db84: e1a00005 mov r0, r5
db88: ebffd0c2 bl 1e98 <rtems_filesystem_prefix_separators>
db8c: e0857000 add r7, r5, r0
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
db90: e1a00007 mov r0, r7
db94: eb0005ce bl f2d4 <strlen>
db98: e28d5004 add r5, sp, #4
db9c: e3a0c000 mov ip, #0
dba0: e1a01000 mov r1, r0
dba4: e1a0200c mov r2, ip
dba8: e1a00007 mov r0, r7
dbac: e1a03005 mov r3, r5
dbb0: e58dc000 str ip, [sp]
dbb4: ebffd0dd bl 1f30 <rtems_filesystem_evaluate_relative_path>
0, &loc, false );
if ( result != 0 ) {
dbb8: e3500000 cmp r0, #0
dbbc: 1a000033 bne dc90 <unlink+0x164>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
return -1;
}
if ( !loc.ops->node_type_h ) {
dbc0: e59d2010 ldr r2, [sp, #16]
dbc4: e5923010 ldr r3, [r2, #16]
dbc8: e3530000 cmp r3, #0
dbcc: 0a00003c beq dcc4 <unlink+0x198>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
dbd0: e1a00005 mov r0, r5
dbd4: e1a0e00f mov lr, pc
dbd8: e12fff13 bx r3
dbdc: e3500001 cmp r0, #1
dbe0: 0a00004b beq dd14 <unlink+0x1e8>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( EISDIR );
}
if ( !loc.ops->unlink_h ) {
dbe4: e59d2010 ldr r2, [sp, #16]
dbe8: e592300c ldr r3, [r2, #12]
dbec: e3530000 cmp r3, #0
dbf0: 0a000033 beq dcc4 <unlink+0x198>
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
dbf4: e1a00004 mov r0, r4
dbf8: e1a01005 mov r1, r5
dbfc: e1a0e00f mov lr, pc
dc00: e12fff13 bx r3
rtems_filesystem_freenode( &loc );
dc04: e59d3010 ldr r3, [sp, #16]
dc08: e3530000 cmp r3, #0
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*loc.ops->unlink_h)( &parentloc, &loc );
dc0c: e1a07000 mov r7, r0
rtems_filesystem_freenode( &loc );
dc10: 0a000004 beq dc28 <unlink+0xfc>
dc14: e593301c ldr r3, [r3, #28]
dc18: e3530000 cmp r3, #0
dc1c: 11a00005 movne r0, r5
dc20: 11a0e00f movne lr, pc
dc24: 112fff13 bxne r3
if ( free_parentloc )
dc28: e3560000 cmp r6, #0
dc2c: 0a000007 beq dc50 <unlink+0x124>
rtems_filesystem_freenode( &parentloc );
dc30: e59d3024 ldr r3, [sp, #36] ; 0x24
dc34: e3530000 cmp r3, #0
dc38: 0a000004 beq dc50 <unlink+0x124>
dc3c: e593301c ldr r3, [r3, #28]
dc40: e3530000 cmp r3, #0
dc44: 11a00004 movne r0, r4
dc48: 11a0e00f movne lr, pc
dc4c: 112fff13 bxne r3
return result;
}
dc50: e1a00007 mov r0, r7
dc54: e28dd030 add sp, sp, #48 ; 0x30
dc58: e8bd80f0 pop {r4, r5, r6, r7, pc}
parentpathlen = rtems_filesystem_dirname ( path );
if ( parentpathlen == 0 )
rtems_filesystem_get_start_loc( path, &i, &parentloc );
else {
result = rtems_filesystem_evaluate_path( path, parentpathlen,
dc5c: e28d4018 add r4, sp, #24
dc60: e3a0c000 mov ip, #0
dc64: e1a00007 mov r0, r7
dc68: e1a01005 mov r1, r5
dc6c: e3a02002 mov r2, #2
dc70: e1a03004 mov r3, r4
dc74: e58dc000 str ip, [sp]
dc78: ebffd0e8 bl 2020 <rtems_filesystem_evaluate_path>
RTEMS_LIBIO_PERMS_WRITE,
&parentloc,
false );
if ( result != 0 )
dc7c: e3500000 cmp r0, #0
dc80: 03a06001 moveq r6, #1
dc84: 0affffb4 beq db5c <unlink+0x30>
result = (*loc.ops->unlink_h)( &parentloc, &loc );
rtems_filesystem_freenode( &loc );
if ( free_parentloc )
rtems_filesystem_freenode( &parentloc );
dc88: e3e07000 mvn r7, #0 <== NOT EXECUTED
dc8c: eaffffef b dc50 <unlink+0x124> <== NOT EXECUTED
name += rtems_filesystem_prefix_separators( name, strlen( name ) );
result = rtems_filesystem_evaluate_relative_path( name , strlen( name ),
0, &loc, false );
if ( result != 0 ) {
if ( free_parentloc )
dc90: e3560000 cmp r6, #0
dc94: 0afffffb beq dc88 <unlink+0x15c>
rtems_filesystem_freenode( &parentloc );
dc98: e59d3024 ldr r3, [sp, #36] ; 0x24
dc9c: e3530000 cmp r3, #0
dca0: 0afffff8 beq dc88 <unlink+0x15c>
dca4: e593301c ldr r3, [r3, #28]
dca8: e3530000 cmp r3, #0
dcac: 0afffff5 beq dc88 <unlink+0x15c>
dcb0: e1a00004 mov r0, r4
dcb4: e1a0e00f mov lr, pc
dcb8: e12fff13 bx r3
dcbc: e3e07000 mvn r7, #0
dcc0: eaffffe2 b dc50 <unlink+0x124>
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( EISDIR );
}
if ( !loc.ops->unlink_h ) {
rtems_filesystem_freenode( &loc );
dcc4: e592301c ldr r3, [r2, #28] <== NOT EXECUTED
dcc8: e3530000 cmp r3, #0 <== NOT EXECUTED
dccc: 11a00005 movne r0, r5 <== NOT EXECUTED
dcd0: 11a0e00f movne lr, pc <== NOT EXECUTED
dcd4: 112fff13 bxne r3 <== NOT EXECUTED
if ( free_parentloc )
dcd8: e3560000 cmp r6, #0 <== NOT EXECUTED
dcdc: 0a000007 beq dd00 <unlink+0x1d4> <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
dce0: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
dce4: e3530000 cmp r3, #0 <== NOT EXECUTED
dce8: 0a000004 beq dd00 <unlink+0x1d4> <== NOT EXECUTED
dcec: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
dcf0: e3530000 cmp r3, #0 <== NOT EXECUTED
dcf4: 11a00004 movne r0, r4 <== NOT EXECUTED
dcf8: 11a0e00f movne lr, pc <== NOT EXECUTED
dcfc: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
dd00: eb00016e bl e2c0 <__errno> <== NOT EXECUTED
dd04: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
dd08: e5803000 str r3, [r0] <== NOT EXECUTED
dd0c: e3e07000 mvn r7, #0 <== NOT EXECUTED
dd10: eaffffce b dc50 <unlink+0x124> <== NOT EXECUTED
rtems_filesystem_freenode( &parentloc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
if ( (*loc.ops->node_type_h)( &loc ) == RTEMS_FILESYSTEM_DIRECTORY ) {
rtems_filesystem_freenode( &loc );
dd14: e59d3010 ldr r3, [sp, #16]
dd18: e3530000 cmp r3, #0
dd1c: 0a000004 beq dd34 <unlink+0x208>
dd20: e593301c ldr r3, [r3, #28]
dd24: e3530000 cmp r3, #0
dd28: 11a00005 movne r0, r5
dd2c: 11a0e00f movne lr, pc
dd30: 112fff13 bxne r3
if ( free_parentloc )
dd34: e3560000 cmp r6, #0
dd38: 0a000007 beq dd5c <unlink+0x230>
rtems_filesystem_freenode( &parentloc );
dd3c: e59d3024 ldr r3, [sp, #36] ; 0x24 <== NOT EXECUTED
dd40: e3530000 cmp r3, #0 <== NOT EXECUTED
dd44: 0a000004 beq dd5c <unlink+0x230> <== NOT EXECUTED
dd48: e593301c ldr r3, [r3, #28] <== NOT EXECUTED
dd4c: e3530000 cmp r3, #0 <== NOT EXECUTED
dd50: 11a00004 movne r0, r4 <== NOT EXECUTED
dd54: 11a0e00f movne lr, pc <== NOT EXECUTED
dd58: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( EISDIR );
dd5c: eb000157 bl e2c0 <__errno>
dd60: e3a03015 mov r3, #21
dd64: e5803000 str r3, [r0]
dd68: e3e07000 mvn r7, #0
dd6c: eaffffb7 b dc50 <unlink+0x124>
0002ac2c <unmount>:
*/
int unmount(
const char *path
)
{
2ac2c: e92d4030 push {r4, r5, lr}
2ac30: e24dd018 sub sp, sp, #24
2ac34: e1a05000 mov r5, r0
* The root node of the mounted filesytem.
* The node for the directory that the fileystem is mounted on.
* The mount entry that is being refered to.
*/
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
2ac38: eb007be9 bl 49be4 <strlen> 2ac3c: e28d4004 add r4, sp, #4 2ac40: e1a01000 mov r1, r0 2ac44: e3a0c001 mov ip, #1 2ac48: e1a00005 mov r0, r5 2ac4c: e3a02000 mov r2, #0 2ac50: e1a03004 mov r3, r4 2ac54: e58dc000 str ip, [sp] 2ac58: ebff7422 bl 7ce8 <rtems_filesystem_evaluate_path> 2ac5c: e3500000 cmp r0, #0
2ac60: 1a000028 bne 2ad08 <unmount+0xdc>
return -1;
mt_entry = loc.mt_entry;
2ac64: e59d5014 ldr r5, [sp, #20]
fs_mount_loc = &mt_entry->mt_point_node; fs_root_loc = &mt_entry->mt_fs_root;
2ac68: e59d3004 ldr r3, [sp, #4] 2ac6c: e595201c ldr r2, [r5, #28] 2ac70: e1520003 cmp r2, r3
2ac74: 1a000040 bne 2ad7c <unmount+0x150>
/*
* Free the loc node and just use the nodes from the mt_entry .
*/
rtems_filesystem_freenode( &loc );
2ac78: e59d3010 ldr r3, [sp, #16] 2ac7c: e3530000 cmp r3, #0
2ac80: 0a000004 beq 2ac98 <unmount+0x6c>
2ac84: e593301c ldr r3, [r3, #28] 2ac88: e3530000 cmp r3, #0 2ac8c: 11a00004 movne r0, r4 2ac90: 11a0e00f movne lr, pc 2ac94: 112fff13 bxne r3
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x0, &loc, true ) )
return -1;
mt_entry = loc.mt_entry;
fs_mount_loc = &mt_entry->mt_point_node;
2ac98: e5953014 ldr r3, [r5, #20] 2ac9c: e5933028 ldr r3, [r3, #40] ; 0x28 2aca0: e3530000 cmp r3, #0
2aca4: 0a00004e beq 2ade4 <unmount+0x1b8> fs_root_loc = &mt_entry->mt_fs_root;
2aca8: e5953028 ldr r3, [r5, #40] ; 0x28 2acac: e593302c ldr r3, [r3, #44] ; 0x2c 2acb0: e3530000 cmp r3, #0
2acb4: 0a00004a beq 2ade4 <unmount+0x1b8>
* that made the current node thread based instead
* of system based? I thought it was but it doesn't
* look like it in this version.
*/
if ( rtems_filesystem_current.mt_entry == mt_entry )
2acb8: e59f3138 ldr r3, [pc, #312] ; 2adf8 <unmount+0x1cc> 2acbc: e5933000 ldr r3, [r3] 2acc0: e5933014 ldr r3, [r3, #20] 2acc4: e1530005 cmp r3, r5
2acc8: 0a000038 beq 2adb0 <unmount+0x184>
/*
* Verify there are no file systems below the path specified
*/
if ( rtems_filesystem_mount_iterate( is_fs_below_mount_point,
2accc: e59f0128 ldr r0, [pc, #296] ; 2adfc <unmount+0x1d0> 2acd0: e595102c ldr r1, [r5, #44] ; 0x2c 2acd4: ebff76bc bl 87cc <rtems_filesystem_mount_iterate> 2acd8: e3500000 cmp r0, #0
2acdc: 1a000033 bne 2adb0 <unmount+0x184>
* Run the file descriptor table to determine if there are any file
* descriptors that are currently active and reference nodes in the
* file system that we are trying to unmount
*/
if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )
2ace0: e1a00005 mov r0, r5 2ace4: ebff7508 bl 810c <rtems_libio_is_open_files_in_fs> 2ace8: e3500001 cmp r0, #1
2acec: 0a00002f beq 2adb0 <unmount+0x184>
* Allow the file system being unmounted on to do its cleanup.
* If it fails it will set the errno to the approprate value
* and the fileystem will not be modified.
*/
if (( fs_mount_loc->ops->unmount_h )( mt_entry ) != 0 )
2acf0: e5953014 ldr r3, [r5, #20] 2acf4: e1a00005 mov r0, r5 2acf8: e1a0e00f mov lr, pc 2acfc: e593f028 ldr pc, [r3, #40] ; 0x28 2ad00: e2504000 subs r4, r0, #0
2ad04: 0a000002 beq 2ad14 <unmount+0xe8>
*/
rtems_filesystem_freenode( fs_mount_loc );
free( mt_entry );
return 0;
2ad08: e3e00000 mvn r0, #0
}
2ad0c: e28dd018 add sp, sp, #24
2ad10: e8bd8030 pop {r4, r5, pc}
* NOTE: Fatal error is called in a case which should never happen
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
2ad14: e5953028 ldr r3, [r5, #40] ; 0x28 2ad18: e1a00005 mov r0, r5 2ad1c: e1a0e00f mov lr, pc 2ad20: e593f02c ldr pc, [r3, #44] ; 0x2c 2ad24: e2501000 subs r1, r0, #0
2ad28: 1a000025 bne 2adc4 <unmount+0x198>
rtems_status_code rtems_libio_set_private_env(void);
rtems_status_code rtems_libio_share_private_env(rtems_id task_id) ;
static inline void rtems_libio_lock( void )
{
rtems_semaphore_obtain( rtems_libio_semaphore, RTEMS_WAIT, RTEMS_NO_TIMEOUT );
2ad2c: e59f40cc ldr r4, [pc, #204] ; 2ae00 <unmount+0x1d4> 2ad30: e1a02001 mov r2, r1 2ad34: e5940000 ldr r0, [r4] 2ad38: ebff85e1 bl c4c4 <rtems_semaphore_obtain>
*/
RTEMS_INLINE_ROUTINE void rtems_chain_extract(
rtems_chain_node *the_node
)
{
_Chain_Extract( the_node );
2ad3c: e1a00005 mov r0, r5 2ad40: ebff88da bl d0b0 <_Chain_Extract>
}
static inline void rtems_libio_unlock( void )
{
rtems_semaphore_release( rtems_libio_semaphore );
2ad44: e5940000 ldr r0, [r4] 2ad48: ebff8625 bl c5e4 <rtems_semaphore_release>
/*
* Free the memory node that was allocated in mount
* Free the memory associated with the extracted mount table entry.
*/
rtems_filesystem_freenode( fs_mount_loc );
2ad4c: e5953014 ldr r3, [r5, #20] 2ad50: e3530000 cmp r3, #0
2ad54: 0a000004 beq 2ad6c <unmount+0x140>
2ad58: e593301c ldr r3, [r3, #28] 2ad5c: e3530000 cmp r3, #0 2ad60: 12850008 addne r0, r5, #8 2ad64: 11a0e00f movne lr, pc 2ad68: 112fff13 bxne r3
free( mt_entry );
2ad6c: e1a00005 mov r0, r5 2ad70: ebff73fe bl 7d70 <free> 2ad74: e3a00000 mov r0, #0
return 0;
2ad78: eaffffe3 b 2ad0c <unmount+0xe0>
/*
* Verify this is the root node for the file system to be unmounted.
*/
if ( fs_root_loc->node_access != loc.node_access ){
rtems_filesystem_freenode( &loc );
2ad7c: e59d3010 ldr r3, [sp, #16] 2ad80: e3530000 cmp r3, #0
2ad84: 0a000004 beq 2ad9c <unmount+0x170>
2ad88: e593301c ldr r3, [r3, #28] 2ad8c: e3530000 cmp r3, #0 2ad90: 11a00004 movne r0, r4 2ad94: 11a0e00f movne lr, pc 2ad98: 112fff13 bxne r3
rtems_set_errno_and_return_minus_one( EACCES );
2ad9c: eb006093 bl 42ff0 <__errno> 2ada0: e3a0300d mov r3, #13 2ada4: e5803000 str r3, [r0] 2ada8: e3e00000 mvn r0, #0 2adac: eaffffd6 b 2ad0c <unmount+0xe0>
* descriptors that are currently active and reference nodes in the
* file system that we are trying to unmount
*/
if ( rtems_libio_is_open_files_in_fs( mt_entry ) == 1 )
rtems_set_errno_and_return_minus_one( EBUSY );
2adb0: eb00608e bl 42ff0 <__errno> 2adb4: e3a03010 mov r3, #16 2adb8: e5803000 str r3, [r0] 2adbc: e3e00000 mvn r0, #0 2adc0: eaffffd1 b 2ad0c <unmount+0xe0>
* This was response was questionable but the best we could
* come up with.
*/
if ((fs_root_loc->ops->fsunmount_me_h )( mt_entry ) != 0){
if (( fs_mount_loc->ops->mount_h )( mt_entry ) != 0 )
2adc4: e1a00005 mov r0, r5 <== NOT EXECUTED 2adc8: e5953014 ldr r3, [r5, #20] <== NOT EXECUTED 2adcc: e1a0e00f mov lr, pc <== NOT EXECUTED 2add0: e593f020 ldr pc, [r3, #32] <== NOT EXECUTED 2add4: e3500000 cmp r0, #0 <== NOT EXECUTED 2add8: 0affffca beq 2ad08 <unmount+0xdc> <== NOT EXECUTED
rtems_fatal_error_occurred( 0 );
2addc: e1a00004 mov r0, r4 <== NOT EXECUTED 2ade0: ebff8798 bl cc48 <rtems_fatal_error_occurred> <== NOT EXECUTED
if ( !fs_mount_loc->ops->unmount_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
if ( !fs_root_loc->ops->fsunmount_me_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
2ade4: eb006081 bl 42ff0 <__errno> <== NOT EXECUTED 2ade8: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 2adec: e5803000 str r3, [r0] <== NOT EXECUTED 2adf0: e3e00000 mvn r0, #0 <== NOT EXECUTED 2adf4: eaffffc4 b 2ad0c <unmount+0xe0> <== NOT EXECUTED
0002ae04 <utime>:
int utime(
const char *path,
const struct utimbuf *times
)
{
2ae04: e92d4070 push {r4, r5, r6, lr}
2ae08: e24dd018 sub sp, sp, #24
2ae0c: e1a05001 mov r5, r1
2ae10: e1a06000 mov r6, r0
rtems_filesystem_location_info_t temp_loc;
int result;
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
2ae14: eb007b72 bl 49be4 <strlen> 2ae18: e28d4004 add r4, sp, #4 2ae1c: e1a01000 mov r1, r0 2ae20: e3a0c001 mov ip, #1 2ae24: e1a00006 mov r0, r6 2ae28: e3a02000 mov r2, #0 2ae2c: e1a03004 mov r3, r4 2ae30: e58dc000 str ip, [sp] 2ae34: ebff73ab bl 7ce8 <rtems_filesystem_evaluate_path> 2ae38: e3500000 cmp r0, #0
2ae3c: 1a00001b bne 2aeb0 <utime+0xac>
return -1;
if ( !temp_loc.ops->utime_h ){
2ae40: e59d2010 ldr r2, [sp, #16] 2ae44: e5923030 ldr r3, [r2, #48] ; 0x30 2ae48: e3530000 cmp r3, #0
2ae4c: 0a00000f beq 2ae90 <utime+0x8c>
rtems_filesystem_freenode( &temp_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime );
2ae50: e8950006 ldm r5, {r1, r2}
2ae54: e1a00004 mov r0, r4
2ae58: e1a0e00f mov lr, pc
2ae5c: e12fff13 bx r3
rtems_filesystem_freenode( &temp_loc );
2ae60: e59d3010 ldr r3, [sp, #16] 2ae64: e3530000 cmp r3, #0
if ( !temp_loc.ops->utime_h ){
rtems_filesystem_freenode( &temp_loc );
rtems_set_errno_and_return_minus_one( ENOTSUP );
}
result = (*temp_loc.ops->utime_h)( &temp_loc, times->actime, times->modtime );
2ae68: e1a05000 mov r5, r0
rtems_filesystem_freenode( &temp_loc );
2ae6c: 0a000004 beq 2ae84 <utime+0x80>
2ae70: e593301c ldr r3, [r3, #28] 2ae74: e3530000 cmp r3, #0 2ae78: 11a00004 movne r0, r4 2ae7c: 11a0e00f movne lr, pc 2ae80: 112fff13 bxne r3
return result;
}
2ae84: e1a00005 mov r0, r5
2ae88: e28dd018 add sp, sp, #24
2ae8c: e8bd8070 pop {r4, r5, r6, pc}
if ( rtems_filesystem_evaluate_path( path, strlen( path ), 0x00, &temp_loc, true ) )
return -1;
if ( !temp_loc.ops->utime_h ){
rtems_filesystem_freenode( &temp_loc );
2ae90: e592301c ldr r3, [r2, #28] <== NOT EXECUTED 2ae94: e3530000 cmp r3, #0 <== NOT EXECUTED 2ae98: 11a00004 movne r0, r4 <== NOT EXECUTED 2ae9c: 11a0e00f movne lr, pc <== NOT EXECUTED 2aea0: 112fff13 bxne r3 <== NOT EXECUTED
rtems_set_errno_and_return_minus_one( ENOTSUP );
2aea4: eb006051 bl 42ff0 <__errno> <== NOT EXECUTED 2aea8: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED 2aeac: e5803000 str r3, [r0] <== NOT EXECUTED
2aeb0: e3e05000 mvn r5, #0 2aeb4: eafffff2 b 2ae84 <utime+0x80>
00019ff0 <write>:
)
{
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
19ff0: e59f30bc ldr r3, [pc, #188] ; 1a0b4 <write+0xc4> 19ff4: e5933000 ldr r3, [r3] 19ff8: e1500003 cmp r0, r3
ssize_t write(
int fd,
const void *buffer,
size_t count
)
{
19ffc: e92d4810 push {r4, fp, lr}
ssize_t rc;
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
1a000: 2a00001c bcs 1a078 <write+0x88>
iop = rtems_libio_iop( fd );
1a004: e59f40ac ldr r4, [pc, #172] ; 1a0b8 <write+0xc8> 1a008: e5944000 ldr r4, [r4] 1a00c: e0844300 add r4, r4, r0, lsl #6
rtems_libio_check_is_open( iop );
1a010: e5940014 ldr r0, [r4, #20] 1a014: e3100c01 tst r0, #256 ; 0x100
1a018: 0a000016 beq 1a078 <write+0x88> rtems_libio_check_buffer( buffer );
1a01c: e3510000 cmp r1, #0
1a020: 0a00001e beq 1a0a0 <write+0xb0> rtems_libio_check_count( count );
1a024: e3520000 cmp r2, #0
1a028: 01a00002 moveq r0, r2
1a02c: 08bd8810 popeq {r4, fp, pc}
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
1a030: e3100004 tst r0, #4
1a034: 0a00000f beq 1a078 <write+0x88>
/*
* Now process the write() request.
*/
if ( !iop->handlers->write_h )
1a038: e594303c ldr r3, [r4, #60] ; 0x3c 1a03c: e593300c ldr r3, [r3, #12] 1a040: e3530000 cmp r3, #0
1a044: 0a000010 beq 1a08c <write+0x9c>
rtems_set_errno_and_return_minus_one( ENOTSUP );
rc = (*iop->handlers->write_h)( iop, buffer, count );
1a048: e1a00004 mov r0, r4 1a04c: e1a0e00f mov lr, pc 1a050: e12fff13 bx r3
if ( rc > 0 )
1a054: e3500000 cmp r0, #0
1a058: d8bd8810 pople {r4, fp, pc}
iop->offset += rc;
1a05c: e284c00c add ip, r4, #12
1a060: e89c1800 ldm ip, {fp, ip}
1a064: e09b2000 adds r2, fp, r0
1a068: e0ac3fc0 adc r3, ip, r0, asr #31
1a06c: e584200c str r2, [r4, #12]
1a070: e5843010 str r3, [r4, #16]
return rc;
}
1a074: e8bd8810 pop {r4, fp, pc}
rtems_libio_check_fd( fd ); iop = rtems_libio_iop( fd ); rtems_libio_check_is_open( iop ); rtems_libio_check_buffer( buffer ); rtems_libio_check_count( count ); rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
1a078: ebffd090 bl e2c0 <__errno> <== NOT EXECUTED
1a07c: e3a03009 mov r3, #9 <== NOT EXECUTED
1a080: e5803000 str r3, [r0] <== NOT EXECUTED
1a084: e3e00000 mvn r0, #0 <== NOT EXECUTED
1a088: e8bd8810 pop {r4, fp, pc} <== NOT EXECUTED
/*
* Now process the write() request.
*/
if ( !iop->handlers->write_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
1a08c: ebffd08b bl e2c0 <__errno> <== NOT EXECUTED
1a090: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
1a094: e5803000 str r3, [r0] <== NOT EXECUTED
1a098: e3e00000 mvn r0, #0 <== NOT EXECUTED
1a09c: e8bd8810 pop {r4, fp, pc} <== NOT EXECUTED
rtems_libio_t *iop;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_buffer( buffer );
1a0a0: ebffd086 bl e2c0 <__errno> <== NOT EXECUTED
1a0a4: e3a03016 mov r3, #22 <== NOT EXECUTED
1a0a8: e5803000 str r3, [r0] <== NOT EXECUTED
1a0ac: e3e00000 mvn r0, #0 <== NOT EXECUTED
1a0b0: e8bd8810 pop {r4, fp, pc} <== NOT EXECUTED
00006204 <writev>:
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
6204: e59f3174 ldr r3, [pc, #372] ; 6380 <writev+0x17c>
6208: e5933000 ldr r3, [r3]
620c: e1500003 cmp r0, r3
ssize_t writev(
int fd,
const struct iovec *iov,
int iovcnt
)
{
6210: e92d49f0 push {r4, r5, r6, r7, r8, fp, lr}
6214: e1a05002 mov r5, r2
int bytes;
rtems_libio_t *iop;
ssize_t old;
bool all_zeros;
rtems_libio_check_fd( fd );
6218: 2a00004c bcs 6350 <writev+0x14c>
iop = rtems_libio_iop( fd );
621c: e59f3160 ldr r3, [pc, #352] ; 6384 <writev+0x180>
6220: e5937000 ldr r7, [r3]
6224: e0877300 add r7, r7, r0, lsl #6
rtems_libio_check_is_open( iop );
6228: e5973014 ldr r3, [r7, #20]
622c: e3130c01 tst r3, #256 ; 0x100
6230: 0a000046 beq 6350 <writev+0x14c>
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
6234: e3130004 tst r3, #4
6238: 0a000044 beq 6350 <writev+0x14c>
/*
* Argument validation on IO vector
*/
if ( !iov )
623c: e3510000 cmp r1, #0
6240: 0a00003c beq 6338 <writev+0x134>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt <= 0 )
6244: e3520000 cmp r2, #0
6248: da00003a ble 6338 <writev+0x134>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iovcnt > IOV_MAX )
624c: e3520b01 cmp r2, #1024 ; 0x400
6250: ca000038 bgt 6338 <writev+0x134>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !iop->handlers->write_h )
6254: e597303c ldr r3, [r7, #60] ; 0x3c
6258: e593300c ldr r3, [r3, #12]
625c: e3530000 cmp r3, #0
6260: 0a000041 beq 636c <writev+0x168>
rtems_set_errno_and_return_minus_one( ENOTSUP );
6264: e1a04001 mov r4, r1
6268: e3a01000 mov r1, #0
626c: e1a02004 mov r2, r4
6270: e3a06001 mov r6, #1
6274: e1a08001 mov r8, r1
6278: ea000000 b 6280 <writev+0x7c>
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
627c: e1a08003 mov r8, r3
if ( !iov[v].iov_base )
6280: e5923000 ldr r3, [r2]
6284: e3530000 cmp r3, #0
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
6288: e2811001 add r1, r1, #1
if ( !iov[v].iov_base )
628c: 0a000029 beq 6338 <writev+0x134>
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len < 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
6290: e5920004 ldr r0, [r2, #4]
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
6294: e0883000 add r3, r8, r0
if ( total < old || total > SSIZE_MAX )
6298: e1580003 cmp r8, r3
629c: d3a08000 movle r8, #0
62a0: c3a08001 movgt r8, #1
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len < 0 )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( iov[v].iov_len )
62a4: e3500000 cmp r0, #0
62a8: 13a06000 movne r6, #0
all_zeros = false;
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
62ac: e1988fa3 orrs r8, r8, r3, lsr #31
62b0: 1a000020 bne 6338 <writev+0x134>
* this loop does that check as well and sets "all-zero" appropriately.
* The variable "all_zero" is used as an early exit point before
* entering the write loop.
*/
all_zeros = true;
for ( old=0, total=0, v=0 ; v < iovcnt ; v++ ) {
62b4: e1550001 cmp r5, r1
62b8: e2822008 add r2, r2, #8
62bc: caffffee bgt 627c <writev+0x78>
}
/*
* A writev with all zeros is supposed to have no effect per OpenGroup.
*/
if ( all_zeros == true ) {
62c0: e3560000 cmp r6, #0
62c4: 1a00001f bne 6348 <writev+0x144>
62c8: e1a08006 mov r8, r6
62cc: ea000002 b 62dc <writev+0xd8>
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
62d0: e1550006 cmp r5, r6
62d4: e2844008 add r4, r4, #8
62d8: da00001a ble 6348 <writev+0x144>
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
62dc: e5942004 ldr r2, [r4, #4]
62e0: e3520000 cmp r2, #0
}
/*
* Now process the writev().
*/
for ( total=0, v=0 ; v < iovcnt ; v++ ) {
62e4: e2866001 add r6, r6, #1
/* all zero lengths has no effect */
if ( iov[v].iov_len == 0 )
62e8: 0afffff8 beq 62d0 <writev+0xcc>
continue;
bytes = (*iop->handlers->write_h)( iop, iov[v].iov_base, iov[v].iov_len );
62ec: e5941000 ldr r1, [r4]
62f0: e597303c ldr r3, [r7, #60] ; 0x3c
62f4: e1a00007 mov r0, r7
62f8: e1a0e00f mov lr, pc
62fc: e593f00c ldr pc, [r3, #12]
if ( bytes < 0 )
6300: e3500000 cmp r0, #0
6304: ba000016 blt 6364 <writev+0x160>
return -1;
if ( bytes > 0 ) {
6308: 0a000006 beq 6328 <writev+0x124>
iop->offset += bytes;
630c: e287c00c add ip, r7, #12
6310: e89c1800 ldm ip, {fp, ip}
6314: e09b2000 adds r2, fp, r0
6318: e0ac3fc0 adc r3, ip, r0, asr #31
631c: e587200c str r2, [r7, #12]
6320: e5873010 str r3, [r7, #16]
total += bytes;
6324: e0888000 add r8, r8, r0
}
if (bytes != iov[ v ].iov_len)
6328: e5943004 ldr r3, [r4, #4]
632c: e1500003 cmp r0, r3
6330: 0affffe6 beq 62d0 <writev+0xcc>
6334: ea000003 b 6348 <writev+0x144> <== NOT EXECUTED
/* check for wrap */
old = total;
total += iov[v].iov_len;
if ( total < old || total > SSIZE_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
6338: eb002451 bl f484 <__errno>
633c: e3a03016 mov r3, #22
6340: e5803000 str r3, [r0]
6344: e3e08000 mvn r8, #0
if (bytes != iov[ v ].iov_len)
break;
}
return total;
}
6348: e1a00008 mov r0, r8
634c: e8bd89f0 pop {r4, r5, r6, r7, r8, fp, pc}
bool all_zeros;
rtems_libio_check_fd( fd );
iop = rtems_libio_iop( fd );
rtems_libio_check_is_open( iop );
rtems_libio_check_permissions_with_error( iop, LIBIO_FLAGS_WRITE, EBADF );
6350: eb00244b bl f484 <__errno>
6354: e3a03009 mov r3, #9
6358: e5803000 str r3, [r0]
635c: e3e08000 mvn r8, #0
6360: eafffff8 b 6348 <writev+0x144>
if ( iov[v].iov_len == 0 )
continue;
bytes = (*iop->handlers->write_h)( iop, iov[v].iov_base, iov[v].iov_len );
if ( bytes < 0 )
6364: e3e08000 mvn r8, #0 <== NOT EXECUTED
6368: eafffff6 b 6348 <writev+0x144> <== NOT EXECUTED
if ( iovcnt > IOV_MAX )
rtems_set_errno_and_return_minus_one( EINVAL );
if ( !iop->handlers->write_h )
rtems_set_errno_and_return_minus_one( ENOTSUP );
636c: eb002444 bl f484 <__errno> <== NOT EXECUTED
6370: e3a03086 mov r3, #134 ; 0x86 <== NOT EXECUTED
6374: e5803000 str r3, [r0] <== NOT EXECUTED
6378: e3e08000 mvn r8, #0 <== NOT EXECUTED
637c: eafffff1 b 6348 <writev+0x144> <== NOT EXECUTED